├── .gitattributes ├── .github ├── dependabot.yml └── workflows │ ├── gradle-wrapper-validation.yml │ └── gradle.yml ├── .gitignore ├── .travis.yml ├── HEADER ├── LICENSE ├── README.md ├── akarnokd-misc.iml ├── build.gradle ├── checkstyle.xml ├── files ├── ospd.txt └── words.shakespeare.txt ├── gradle.properties ├── gradle ├── javadocStyleSheet.css ├── license.gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── hrings.html ├── out └── production │ └── classes │ └── akka-streams.conf ├── settings.gradle └── src ├── jmh └── java │ └── hu │ └── akarnokd │ ├── asyncenum │ ├── PerfAsyncConsumer.java │ └── PerfSyncConsumer.java │ ├── atomics │ ├── QueueDrainAsync3Perf.java │ ├── QueueDrainAsyncPerf.java │ ├── QueueDrainPerf.java │ └── TerminalAtomics.java │ ├── comparison │ ├── AkkaStreamsCrossMapPerf.java │ ├── AkkaStreamsFlatMapPerf.java │ ├── AkkaStreamsReactorCrossMapPerf.java │ ├── CharsTakeSkipConcatPerf.java │ ├── FlattenCrossMapPerf.java │ ├── FluentIterables.java │ ├── IterableSpliterator.java │ ├── LatchedObserver.java │ ├── LatchedRSObserver.java │ ├── LogSumPerf.java │ ├── MaterializationBenchmarkFanInOutPerf.java │ ├── MonoThenFlatMap.java │ ├── ObservableFlatMapPerf.java │ ├── OnesTypesFlatMap2Perf.java │ ├── OnesTypesFlatMapPerf.java │ ├── ParallelPerf.java │ ├── PublisherFlatMapPerf.java │ ├── SingleFlatMapIterablePerf.java │ ├── StreamVsRxJava.java │ ├── Util.java │ ├── ZeroOnePerf.java │ ├── ZipPerf.java │ ├── classic │ │ ├── ClassicAsyncPerf.java │ │ └── ForEachPerf.java │ └── scrabble │ │ ├── ShakespearePlaysScrabble.java │ │ ├── ShakespearePlaysScrabbleWithAkkaStreamBeta.java │ │ ├── ShakespearePlaysScrabbleWithAkkaStreamOpt.java │ │ ├── ShakespearePlaysScrabbleWithCyclopsReactOpt.java │ │ ├── ShakespearePlaysScrabbleWithDirect.java │ │ ├── ShakespearePlaysScrabbleWithGuava.java │ │ ├── ShakespearePlaysScrabbleWithGuavaBeta.java │ │ ├── ShakespearePlaysScrabbleWithGuavaOpt.java │ │ ├── ShakespearePlaysScrabbleWithI4JOpt.java │ │ ├── ShakespearePlaysScrabbleWithIEOpt.java │ │ ├── ShakespearePlaysScrabbleWithIObsOpt.java │ │ ├── ShakespearePlaysScrabbleWithIx.java │ │ ├── ShakespearePlaysScrabbleWithIxBeta.java │ │ ├── ShakespearePlaysScrabbleWithIxOpt.java │ │ ├── ShakespearePlaysScrabbleWithJOOL.java │ │ ├── ShakespearePlaysScrabbleWithJOOLBeta.java │ │ ├── ShakespearePlaysScrabbleWithJOOLOpt.java │ │ ├── ShakespearePlaysScrabbleWithLSA.java │ │ ├── ShakespearePlaysScrabbleWithLSABeta.java │ │ ├── ShakespearePlaysScrabbleWithNonParallelLSA.java │ │ ├── ShakespearePlaysScrabbleWithNonParallelLSABeta.java │ │ ├── ShakespearePlaysScrabbleWithNonParallelStreams.java │ │ ├── ShakespearePlaysScrabbleWithNonParallelStreamsBeta.java │ │ ├── ShakespearePlaysScrabbleWithParallelStreams.java │ │ ├── ShakespearePlaysScrabbleWithParallelStreamsBeta.java │ │ ├── ShakespearePlaysScrabbleWithR4J.java │ │ ├── ShakespearePlaysScrabbleWithR4JBeta.java │ │ ├── ShakespearePlaysScrabbleWithR4JOpt.java │ │ ├── ShakespearePlaysScrabbleWithReactor3.java │ │ ├── ShakespearePlaysScrabbleWithReactor3Beta.java │ │ ├── ShakespearePlaysScrabbleWithReactor3Opt.java │ │ ├── ShakespearePlaysScrabbleWithReactor3ParallelOpt.java │ │ ├── ShakespearePlaysScrabbleWithRxJava1.java │ │ ├── ShakespearePlaysScrabbleWithRxJava1Beta.java │ │ ├── ShakespearePlaysScrabbleWithRxJava1Opt.java │ │ ├── ShakespearePlaysScrabbleWithRxJava2Flowable.java │ │ ├── ShakespearePlaysScrabbleWithRxJava2FlowableBeta.java │ │ ├── ShakespearePlaysScrabbleWithRxJava2FlowableOpt.java │ │ ├── ShakespearePlaysScrabbleWithRxJava2FlowableOpt2.java │ │ ├── ShakespearePlaysScrabbleWithRxJava2FlowableOpt3.java │ │ ├── ShakespearePlaysScrabbleWithRxJava2Observable.java │ │ ├── ShakespearePlaysScrabbleWithRxJava2ObservableBeta.java │ │ ├── ShakespearePlaysScrabbleWithRxJava2ObservableOpt.java │ │ ├── ShakespearePlaysScrabbleWithRxJava2ParallelOpt.java │ │ ├── ShakespearePlaysScrabbleWithRxJava3FlowableOpt.java │ │ ├── ShakespearePlaysScrabbleWithRxJava3ObservableOpt.java │ │ ├── ShakespearePlaysScrabbleWithRxJava3ParallelDiag.java │ │ ├── ShakespearePlaysScrabbleWithRxJava3ParallelOpt.java │ │ ├── ShakespearePlaysScrabbleWithStreams.java │ │ └── ShakespearePlaysScrabbleWithStreamsBeta.java │ ├── iterables │ └── LambdaSingletonPerf.java │ ├── queue │ ├── ExamplePerf.java │ ├── SpscIntArrayQueuePerf.java │ └── SpscIntArrayQueueXPerf.java │ ├── reactive │ ├── comparison │ │ ├── consumers │ │ │ ├── PerfAsyncConsumer.java │ │ │ ├── PerfConsumer.java │ │ │ ├── PerfRxAsyncSingleSubscriber.java │ │ │ ├── PerfRxAsyncSubscriber.java │ │ │ ├── PerfRxSingleSubscriber.java │ │ │ └── PerfRxSubscriber.java │ │ ├── reactor │ │ │ ├── AsyncPerf.java │ │ │ ├── BlockingPerf.java │ │ │ ├── MemoryPerf.java │ │ │ ├── StreamingPerf.java │ │ │ ├── SubjectPerf.java │ │ │ └── SubscribePerf.java │ │ ├── rx1 │ │ │ ├── AsyncPerf.java │ │ │ ├── BlockingPerf.java │ │ │ ├── MemoryPerf.java │ │ │ ├── StreamingPerf.java │ │ │ ├── SubjectPerf.java │ │ │ └── SubscribePerf.java │ │ └── rx2 │ │ │ ├── AsyncPerf.java │ │ │ ├── BlockingPerf.java │ │ │ ├── MemoryPerf.java │ │ │ ├── StreamingPerf.java │ │ │ ├── SubjectPerf.java │ │ │ └── SubscribePerf.java │ ├── ipc │ │ └── SocketNetworkNotification.java │ ├── lowalloc │ │ └── LcRangePerfComparisonPerf.java │ └── nio │ │ ├── BufferPerf.java │ │ └── NIONetworkNotification.java │ └── rxjava2 │ ├── DisposableContainerPerf.java │ ├── DisposableContainerSyncPerf.java │ ├── PerfBoundedSubscriber.java │ ├── PerfConsumer.java │ └── PublishProcessorPerf.java ├── main └── java │ ├── akka-streams.conf │ └── hu │ └── akarnokd │ ├── akka │ ├── AkkaHello.java │ └── AkkaRange.java │ ├── asm │ └── ModuleWriting.java │ ├── asyncenum │ ├── Ax.java │ ├── AxObserveOn.java │ ├── AxRange.java │ ├── AxSubscribeOn.java │ ├── IAsyncEnumerable.java │ ├── IAsyncEnumerator.java │ └── TestAsyncConsumer.java │ ├── enumerables │ ├── BasicEnumerator.java │ ├── IECollect.java │ ├── IEConcatArray.java │ ├── IEFilter.java │ ├── IEFlatMapIterable.java │ ├── IEFromCharSequence.java │ ├── IEFromIterable.java │ ├── IEJust.java │ ├── IEMap.java │ ├── IEMaxInt.java │ ├── IESkip.java │ ├── IESumInt.java │ ├── IESumLong.java │ ├── IETake.java │ ├── IEnumerable.java │ └── IEnumerator.java │ ├── fallout76 │ ├── Ba2File.java │ ├── Ba2FileCreator.java │ ├── Ba2FileEntry.java │ ├── DataInputByteBuffer.java │ ├── EnemyCurveTableListing.java │ ├── EsmExport.java │ ├── Fallout76LootGenerator.java │ ├── TesStringsData.java │ ├── WeaponCurveTableListing.java │ └── old │ │ ├── EditorIDFinder.java │ │ ├── EditorIDScanner.java │ │ ├── Fallout76EnemyInfo.java │ │ └── package-info.java │ ├── imperium │ ├── WavExport.java │ └── XMFExplorer.java │ ├── io │ ├── ConcatInputStream.java │ ├── DebugOutputStream.java │ ├── FileReadSpeed.java │ └── LongClass.java │ ├── iterables │ ├── SingletonIterator.java │ ├── SingletonIteratorBugged.java │ ├── SingletonSet.java │ └── SingletonSetBugged.java │ ├── linearprogramming │ └── TaskTimeDetect.java │ ├── math │ ├── NumberFrom1to10NoConcat.java │ └── NumberFrom1to9.java │ ├── minio │ └── MinioUploader.java │ ├── misc │ ├── A.java │ ├── AllCombinations.java │ ├── BoxOColor.java │ ├── BrInExtraNewLine.java │ ├── BubblyVowels.java │ ├── Bug20216.java │ ├── Button45.java │ ├── CP037.java │ ├── DigitSwapper.java │ ├── ExclusionForwardBack.java │ ├── ExpandKeysInMap.java │ ├── Finput.java │ ├── FoBar.java │ ├── HasAllLetters.java │ ├── ImgRotate.java │ ├── InferenceError.java │ ├── Interfaceoverride.java │ ├── InterfacesC.java │ ├── LastCreatedDir.java │ ├── Lead.java │ ├── LongestEventSub.java │ ├── LoopIncr.java │ ├── MayBy.java │ ├── MonoAppended.java │ ├── NPEPuzzle.java │ ├── OpenFromDesktop.java │ ├── ParallelCalc.java │ ├── ParallelPrinter.java │ ├── ParallelSum.java │ ├── Parking.java │ ├── PrimeCounter.java │ ├── ProcessCommands.java │ ├── Puzzler1to9.java │ ├── Recolor.java │ ├── RecordVarargs.java │ ├── Rotator.java │ ├── Scaledown.java │ ├── ScannerClose2.java │ ├── ScannerNext.java │ ├── Scansort.java │ ├── SimpleDateAdd.java │ ├── SmallJPEG.java │ ├── SortySort.java │ ├── SplitNKeep.java │ ├── TaxiCount.java │ ├── UseSiteTypeAnnot.java │ └── UserHome.java │ ├── planb │ ├── MergeLabels.java │ └── PlanBCleanupCS.java │ ├── queue │ ├── ArrayQueue.java │ ├── IQueue.java │ ├── IntQueue.java │ ├── MpscLinkedArrayQueue.java │ ├── MpscLinkedArrayQueueV2.java │ ├── MpscLinkedArrayQueueV3.java │ ├── SpSrcQueue.java │ ├── SpscIntArrayQueue.java │ ├── SpscIntArrayQueueAtomic.java │ ├── SpscIntLinkedArrayQueue.java │ ├── SpscLongArrayQueue.java │ ├── SpscLongLinkedArrayQueue.java │ └── SpscStealableArrayQeque.java │ ├── reactive │ ├── lowalloc │ │ ├── LcIntermediateObservable.java │ │ ├── LcObservable.java │ │ ├── LcObservableJust.java │ │ ├── LcObservableMap.java │ │ ├── LcObservableRange.java │ │ └── LcSourceObservable.java │ └── observables │ │ ├── BooleanDisposable.java │ │ ├── IDisposable.java │ │ ├── IObservable.java │ │ └── IObserver.java │ ├── rxjava │ ├── ActionInBetween.java │ ├── CompletableFlatMapSingleToCompletable.java │ ├── ConditionalCompactedStream.java │ ├── DebounceFirst.java │ ├── EmitterTest.java │ ├── EmitterTestv2.java │ ├── Example.java │ ├── GroupByTest2.java │ ├── MathObservable.java │ ├── Merge4691.java │ ├── MethodDiff.java │ ├── OnSubscribeMinMax.java │ ├── OnSubscribeSumDouble.java │ ├── OnSubscribeSumFloat.java │ ├── OnSubscribeSumInt.java │ ├── OnSubscribeSumLong.java │ ├── OperatorMinMax.java │ ├── OperatorSum.java │ ├── ScalarDeferredSubscriber.java │ ├── ShareLatest.java │ ├── SingleAsync.java │ ├── SubscriberReuse.java │ ├── ThrottleFirstExample.java │ ├── TrackSubscriber1.java │ ├── TransactionSubjectPlaypen.java │ └── javadoc │ │ └── AddCanonical.java │ ├── rxjava2 │ ├── BufferSkipAsync.java │ ├── CacheAndBlock.java │ ├── Cartesian.java │ ├── Coincidence.java │ ├── Counts.java │ ├── DeferredScalarSubscriber.java │ ├── DoOnErrorFusion.java │ ├── EIsNotNull.java │ ├── FindGT.java │ ├── FirstAndSample.java │ ├── FixedCompositeDisposable.java │ ├── FlowVsRS.java │ ├── FlowableSignalMapper.java │ ├── FlowableStringInputStream.java │ ├── FlowableSumIntArray.java │ ├── FluxCharSequence.java │ ├── GroupByParallel.java │ ├── InsertHeader.java │ ├── IntDeferredReducerCore.java │ ├── JavadocScrape.java │ ├── LongDeferredReducerCore.java │ ├── MyRxJava2DirWatcher.java │ ├── NoWebMain.java │ ├── OddCall.java │ ├── PersonSeq.java │ ├── ReduceWhile.java │ ├── RefCountGrace.java │ ├── RepeatWhenEmpty.java │ ├── ResumeFilter.java │ ├── RxSynchronousCoarseProfiler.java │ ├── RxSynchronousProfiler.java │ ├── ShiftByCount.java │ ├── SingleFlatMapIterableFlowable.java │ ├── SingleFlatMapIterableObservable.java │ ├── SomeAsyncApiBridge.java │ ├── StripedCompositeDisposable.java │ ├── SubscribeOnFalse.java │ ├── TrackSubscriber.java │ ├── TrampolineInfinite.java │ ├── Transformers.java │ ├── WeakParallelScheduler.java │ └── WhichThread.java │ ├── rxjava3 │ ├── ConcatGroupTest.java │ ├── DebounceAndBufferWithTime.java │ ├── GroupByAbandon.java │ ├── MarblesAddBackground.java │ ├── OnErrorResumeNextInSequence.java │ ├── ParallelFromBatchPublisher.java │ ├── ParallelFromPublisher.java │ ├── ShareExample.java │ ├── SomeCombine.java │ └── UsingWhen.java │ ├── rxreactor │ └── RxReactorDiff.java │ ├── starfield │ └── Crafter.java │ ├── stream │ └── StreamFilterMapCollect.java │ └── theplanetcrafter │ ├── BuildMap.java │ ├── CleanupCS.java │ ├── DropProbabilityCalc.java │ ├── FileToByteArrayText.java │ ├── FusionReactorFix.java │ ├── GridMap.java │ ├── HumbleMap.java │ ├── InventoryPrintLn.java │ ├── LIIDRegen.java │ ├── LarvaeMap.java │ ├── PositionEchoClient.java │ ├── PositionEchoHost.java │ ├── SaveCheck.java │ └── SaveDisplayNameFixer.java └── test └── java ├── GroupByConcatMapTest.java ├── hu └── akarnokd │ ├── asyncenum │ ├── AxRangeTest.java │ └── StageCancel.java │ ├── enumerables │ └── IEnumerableTest.java │ ├── helidon │ └── CrossFlatMapIterableTest.java │ ├── iterables │ ├── IxNulls.java │ └── SingletonIteratorTest.java │ ├── queue │ ├── MpmcPollTest.java │ ├── MpscLinkedArrayQueueTest.java │ ├── MpscLinkedArrayQueueV2Test.java │ ├── SpscIntArrayQueueTest.java │ ├── SpscIntLinkedArrayQueueTest.java │ ├── SpscLongArrayQueueTest.java │ └── SpscLongLinkedArrayQueueTest.java │ ├── reactive │ ├── SubmissionPublisherTest.java │ ├── nio │ │ └── BasicNIOTest.java │ └── observable │ │ └── IObservableTest.java │ ├── reactivestreams │ └── tck │ │ └── EmptyPublisherTckTest.java │ ├── reactor │ ├── BackpressureProblem.java │ ├── BufferUntilTest.java │ ├── BufferWhenTest.java │ ├── DelayedBuffer.java │ ├── DoOnSubscribeTest.java │ ├── FilterWhenTest.java │ ├── FlatMapMonoVoid.java │ ├── FluxMergeTest.java │ ├── GroupParallel.java │ ├── MonoTimeoutTest.java │ ├── PickNextIndexed.java │ ├── Reactor2Test.java │ ├── RxReactorInteropTest.java │ ├── SchedulerLeak.java │ ├── SchedulerLeakRx.java │ ├── StreamRemainingTest.java │ └── TestLazy.java │ ├── retrofit2 │ └── ResponseBodyNull.java │ ├── rxjava │ ├── ATest.java │ ├── AmbTest.java │ ├── AutoRemoveSubscription.java │ ├── BufferStartEndTest.java │ ├── BufferUntil.java │ ├── BufferUntilWithPublish.java │ ├── CompletableConcat1.java │ ├── CompletableConcat2.java │ ├── CompleteDos.java │ ├── ConcatReplayTest.java │ ├── ConcatWithTest.java │ ├── ConcatWithTest2.java │ ├── ConcatWithTest3.java │ ├── DelayingScheduler.java │ ├── DoOnSubscribe1.java │ ├── FirstAndThrowTest.java │ ├── FromCallCancel.java │ ├── FromToSingle.java │ ├── GroupByTest.java │ ├── GroupConcat.java │ ├── InferenceSO.java │ ├── InteropCheck.java │ ├── InterruptFlow.java │ ├── ListFlatMappingTest.java │ ├── ObserveOnTest.java │ ├── OutOfOrder.java │ ├── OutOfOrder2.java │ ├── OutOfOrder3.java │ ├── OutOfOrder4.java │ ├── OutOfOrder5.java │ ├── ProblemTestCase.java │ ├── PublishBufferZip.java │ ├── PublishExample.java │ ├── PublishSubjectRaceTest.java │ ├── RecurseWithDefer.java │ ├── ReduceAnonymous.java │ ├── Replay1RetentionTest.java │ ├── ReplayTimeout.java │ ├── RetryWhenCompile.java │ ├── ScanReplay.java │ ├── SingleUnsubscribe.java │ ├── SingleUntil.java │ ├── StackOverflowDepth.java │ ├── Ternary.java │ ├── TimeoutCancelTest.java │ ├── ZipRandomTest.java │ ├── ZipRxJava.java │ └── strings │ │ └── LinesBackpressure.java │ ├── rxjava2 │ ├── AdaptiveDebounce.java │ ├── Amb2Test.java │ ├── AndThenTest.java │ ├── AssemblyHooksExample.java │ ├── BasicPrint.java │ ├── BasicPrint2.java │ ├── BasicSingleCreateTest.java │ ├── BehaviorMulticast.java │ ├── BehaviorSubjectCombineLatest.java │ ├── BehaviorSubjectCombineLatestTest.java │ ├── BehaviorSubjectSignals.java │ ├── BehaviorWithLatestTest.java │ ├── BlockingSingleTest.java │ ├── BlockingSubscribeOrdering.java │ ├── BufferDebounce.java │ ├── BufferDelayErrorTest.java │ ├── BufferExactDisposeTest.java │ ├── BufferSkipSingleZero.java │ ├── BufferUntilChanged.java │ ├── BufferWithConditionAndTime.java │ ├── CacheParallel.java │ ├── CombineLatestError.java │ ├── ConcatAnomalyTest.java │ ├── ConcatEagerDebounceTest.java │ ├── ConcatMapDelayTest.java │ ├── ConcatRange.java │ ├── ConcurrentSingleCache.java │ ├── ConnectConnect.java │ ├── Covariance.java │ ├── CreateFlatFlat.java │ ├── CrossTypeBackpressure.java │ ├── CustomFlowableTest.java │ ├── CustomSchedulerTimeout.java │ ├── DebounceEmpty.java │ ├── DebounceRailTest.java │ ├── DebounceRange.java │ ├── DebounceTimeDrop.java │ ├── DelayBetween.java │ ├── DistinctUntilChangedNumericDeltaTest.java │ ├── DoOnDisposeBug.java │ ├── DoOnErrorInside.java │ ├── DoOnSubscribe2.java │ ├── DropBlocking.java │ ├── ErrorRemap.java │ ├── ExceptionAfterDispose.java │ ├── FileReaderTest.java │ ├── FlatMapCompletableThread.java │ ├── FlatMapDisposeTest.java │ ├── FlatMapFatal.java │ ├── FlatMapIterableSharedTest.java │ ├── FlatMapWithTwoErrors.java │ ├── FlowableIfNonEmptyComposeTest.java │ ├── FlowableMergeTest.java │ ├── FlowableStringInputStreamTest.java │ ├── FromCallableConcatMapTest.java │ ├── FromIterableFlatMap.java │ ├── GenerateExampleTest.java │ ├── GroupByFilterTest.java │ ├── GroupByOOME.java │ ├── GroupByTake5.java │ ├── GroupByTaken.java │ ├── GroupByTimeout.java │ ├── GroupSumExample.java │ ├── HookThrowing.java │ ├── InterruptFlow2.java │ ├── IsDisposedTest.java │ ├── Issue5104.java │ ├── ItemTestSO.java │ ├── JavaCompilerBugTest.java │ ├── JoinPairwise.java │ ├── JustFlatMapCallableNull.java │ ├── JustFromEagerCancel.java │ ├── LastZipped.java │ ├── LatestObserveOnTest.java │ ├── LatestSuccessTest.java │ ├── LazyUndeliverable.java │ ├── LineByLine.java │ ├── ListFlattening.java │ ├── ListGrouping.java │ ├── Loading.java │ ├── LockstepObserveOnTest.java │ ├── MapThrowsNull.java │ ├── MatchIndex.java │ ├── MaxByTest.java │ ├── MaybeConcatTest.java │ ├── MergeAmbTest.java │ ├── MergeCompletablesTest.java │ ├── MonoPublishTest.java │ ├── MultiplyDigits.java │ ├── MyClass.java │ ├── NotInFirst.java │ ├── ObsMergeWithCompTest.java │ ├── ObservableConcatEagerTest.java │ ├── ObservableFromFuture.java │ ├── ObservableOnSubscribeTest.java │ ├── OnErrorCrash.java │ ├── PSTestWithTS.java │ ├── PagingFeedbackLoop.java │ ├── ParallelFileProcessing.java │ ├── ParallelInterrupt.java │ ├── ParallelProducing.java │ ├── PartialCollectTest.java │ ├── PeriodicSchedule.java │ ├── PublishExamples.java │ ├── PublishFuncExample.java │ ├── PublishRefCountPublishTest.java │ ├── PublishUndeliverableTest.java │ ├── RedoCountTest.java │ ├── ReentrantSubject.java │ ├── RefCountRace.java │ ├── RefCountTrackingTest.java │ ├── RepeatThread.java │ ├── ReplayOOM.java │ ├── ReplayRefCountSubjectTest.java │ ├── RetryEmptyErrorTest.java │ ├── RetryWhenDelay.java │ ├── RetryWhenManyTypeTest.java │ ├── RetryWhenPlain.java │ ├── RetryWhenTest.java │ ├── RetryWhenTimedTest.java │ ├── RightThread.java │ ├── RxJava2Test.java │ ├── RxJavaFuseTest.java │ ├── RxLosers.java │ ├── RxWeakRef.java │ ├── SampleTest.java │ ├── SequenceEqualsCancelTest.java │ ├── ShareRace.java │ ├── ShareRetry.java │ ├── SingleConcatTest.java │ ├── SingleObserveOnRaceTest.java │ ├── SingleTakeUntilTest.java │ ├── SingleTimeout7514.java │ ├── SingleTimeout7515Rx3.java │ ├── SingleUsingTest.java │ ├── SlidingWindowTest.java │ ├── SomeAsyncApiBridgeTest.java │ ├── SomeClicks.java │ ├── SomeSharedFlow.java │ ├── SortZip.java │ ├── SquareSequenceTest.java │ ├── StageDelays.java │ ├── SubjectRaceTest.java │ ├── SubjectShareTest.java │ ├── SwitchFallback.java │ ├── SwitchFlatMapTest.java │ ├── SwitchIfFewerTest.java │ ├── SwitchMapRace.java │ ├── TakeUntil.java │ ├── TakeUntilTest.java │ ├── TestDoAfterTerminate.java │ ├── TestLazy.java │ ├── TestMockitoCalls.java │ ├── TestObserverDispose.java │ ├── ThrottleLastLeak.java │ ├── ThrottleLastSO.java │ ├── ThrottleLastTest.java │ ├── ThrottleSampleTest.java │ ├── ThrowsSubclass.java │ ├── Timeout800Test.java │ ├── TimeoutCancelv2Test.java │ ├── TimeoutExample.java │ ├── TimeoutTask.java │ ├── TrackedRefcount.java │ ├── UncaughtCrash.java │ ├── UnicastSingleTest.java │ ├── VehicleToFetch.java │ ├── WindowBoundaryIssue.java │ ├── WindowDisposed.java │ ├── WindowInterrupted.java │ ├── WithNextSupplierTest.java │ ├── ZipCrash.java │ ├── ZipInfinite.java │ └── ZipShare.java │ ├── rxjava3 │ ├── BufferStartStop.java │ ├── BufferStartStop2.java │ ├── CompletableAndThenNoError.java │ ├── FlatMapLatest.java │ ├── Issue7502.java │ ├── NestedUsing.java │ ├── OnePerGroup.java │ ├── RangeDelayedRange.java │ ├── RepeatWhenSO.java │ ├── ReplayGroupsWithTimeout.java │ ├── SchedulerPrint.java │ ├── SingleMaybeMock.java │ ├── SomeBlocking.java │ ├── SomeGroupBy1.java │ ├── UndeliverableTest.java │ ├── ZipPattern.java │ └── ZipWithOne.java │ └── utils │ ├── BallisticResist.java │ ├── TestException.java │ └── TestHelper.java └── servicetalk ├── PublishOnOverrideTckTest.java └── PublishOnTest.java /.gitattributes: -------------------------------------------------------------------------------- 1 | # Set default behaviour, in case users don't have core.autocrlf set. 2 | * text=auto 3 | 4 | # Explicitly declare text files we want to always be normalized and converted 5 | # to native line endings on checkout. 6 | *.java text 7 | *.groovy text 8 | *.scala text 9 | *.clj text 10 | *.txt text 11 | *.md text 12 | 13 | # Denote all files that are truly binary and should not be modified. 14 | *.png binary 15 | *.jpg binary 16 | -------------------------------------------------------------------------------- /.github/dependabot.yml: -------------------------------------------------------------------------------- 1 | version: 2 2 | updates: 3 | - package-ecosystem: gradle 4 | directory: "/" 5 | schedule: 6 | interval: daily 7 | time: "04:00" 8 | open-pull-requests-limit: 20 9 | ignore: 10 | - dependency-name: io.servicetalk:servicetalk-concurrent-reactivestreams 11 | versions: 12 | - 0.39.0 13 | -------------------------------------------------------------------------------- /.github/workflows/gradle-wrapper-validation.yml: -------------------------------------------------------------------------------- 1 | name: "Validate Gradle Wrapper" 2 | on: [push, pull_request] 3 | 4 | jobs: 5 | validation: 6 | name: "Validation" 7 | runs-on: ubuntu-latest 8 | steps: 9 | - uses: actions/checkout@v2 10 | - uses: gradle/wrapper-validation-action@v1.0.4 11 | -------------------------------------------------------------------------------- /.github/workflows/gradle.yml: -------------------------------------------------------------------------------- 1 | # This workflow will build a Java project with Gradle 2 | # For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle 3 | 4 | name: Java CI with Gradle 5 | 6 | on: 7 | push: 8 | branches: [ master ] 9 | pull_request: 10 | branches: [ master ] 11 | 12 | jobs: 13 | build: 14 | 15 | runs-on: ubuntu-latest 16 | 17 | steps: 18 | - uses: actions/checkout@v2 19 | - name: Set up JDK 17 20 | uses: actions/setup-java@v1 21 | with: 22 | java-version: 17 23 | - name: Cache Gradle packages 24 | uses: actions/cache@v2 25 | with: 26 | path: ~/.gradle/caches 27 | key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }} 28 | restore-keys: ${{ runner.os }}-gradle 29 | - name: Grant execute permission for gradlew 30 | run: chmod +x gradlew 31 | - name: Build with Gradle 32 | run: ./gradlew assemble --stacktrace 33 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.class 2 | 3 | # Package Files # 4 | *.jar 5 | *.war 6 | *.ear 7 | /build/ 8 | 9 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 10 | 11 | hs_err_pid* 12 | 13 | .gradle 14 | .m2 15 | /.nb-gradle/ 16 | /bin/ 17 | .settings/ 18 | .nb-gradle-properties 19 | .classpath 20 | .project 21 | .settings 22 | .metadata 23 | .checkstyle 24 | bin/ 25 | !/gradle/wrapper/gradle-wrapper.jar 26 | /hotspot_pid*.log 27 | /test-output 28 | .idea -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: java 2 | 3 | jdk: 4 | - openjdk11 5 | 6 | install: true 7 | 8 | # cache between builds 9 | cache: 10 | directories: 11 | - $HOME/.m2 12 | - $HOME/.gradle 13 | 14 | before_install: 15 | - chmod +x gradlew 16 | 17 | script: 18 | - ./gradlew assemble testClasses 19 | -------------------------------------------------------------------------------- /HEADER: -------------------------------------------------------------------------------- 1 | Copyright 2015-2017 David Karnok 2 | 3 | Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in 4 | compliance with the License. You may obtain a copy of the License at 5 | 6 | http://www.apache.org/licenses/LICENSE-2.0 7 | 8 | Unless required by applicable law or agreed to in writing, software distributed under the License is 9 | distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See 10 | the License for the specific language governing permissions and limitations under the License. 11 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # akarnokd-misc 2 | Miscellaneous classes, implementations with gradle and jmh set up 3 | 4 | 5 | -------------------------------------------------------------------------------- /akarnokd-misc.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /gradle.properties: -------------------------------------------------------------------------------- 1 | version=0.1.1 2 | -------------------------------------------------------------------------------- /gradle/license.gradle: -------------------------------------------------------------------------------- 1 | license { 2 | header rootProject.file('HEADER') 3 | ext.year = Calendar.getInstance().get(Calendar.YEAR) 4 | skipExistingHeaders true 5 | ignoreFailures true 6 | } 7 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | distributionBase=GRADLE_USER_HOME 2 | distributionPath=wrapper/dists 3 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.1-bin.zip 4 | networkTimeout=10000 5 | validateDistributionUrl=true 6 | zipStoreBase=GRADLE_USER_HOME 7 | zipStorePath=wrapper/dists 8 | -------------------------------------------------------------------------------- /settings.gradle: -------------------------------------------------------------------------------- 1 | rootProject.name = 'akarnokd-misc' 2 | -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/IterableSpliterator.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2015 José Paumard 3 | * 4 | * This program is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU General Public License 6 | * as published by the Free Software Foundation; either version 2 7 | * of the License, or (at your option) any later version. 8 | * 9 | * This program is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | * GNU General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU General Public License 15 | * along with this program; if not, write to the Free Software 16 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 17 | */ 18 | 19 | package hu.akarnokd.comparison; 20 | 21 | import java.util.*; 22 | 23 | public final class IterableSpliterator { 24 | 25 | private IterableSpliterator() { } 26 | 27 | public static Iterable of(Spliterator spliterator) { 28 | 29 | return () -> Spliterators.iterator(spliterator) ; 30 | } 31 | } -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabble.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabble.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithAkkaStreamBeta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithAkkaStreamBeta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithAkkaStreamOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithAkkaStreamOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithCyclopsReactOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithCyclopsReactOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithDirect.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithDirect.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithGuava.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithGuava.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithGuavaBeta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithGuavaBeta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithGuavaOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithGuavaOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithI4JOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithI4JOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithIEOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithIEOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithIObsOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithIObsOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithIx.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithIx.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithIxBeta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithIxBeta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithIxOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithIxOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithJOOL.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithJOOL.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithJOOLBeta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithJOOLBeta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithJOOLOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithJOOLOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithLSA.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithLSA.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithLSABeta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithLSABeta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithNonParallelLSA.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithNonParallelLSA.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithNonParallelLSABeta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithNonParallelLSABeta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithNonParallelStreams.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithNonParallelStreams.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithNonParallelStreamsBeta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithNonParallelStreamsBeta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithParallelStreams.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithParallelStreams.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithParallelStreamsBeta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithParallelStreamsBeta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithR4J.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithR4J.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithR4JBeta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithR4JBeta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithR4JOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithR4JOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithReactor3.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithReactor3.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithReactor3Beta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithReactor3Beta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithReactor3Opt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithReactor3Opt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithReactor3ParallelOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithReactor3ParallelOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava1.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava1.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava1Beta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava1Beta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava1Opt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava1Opt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2Flowable.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2Flowable.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2FlowableBeta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2FlowableBeta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2FlowableOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2FlowableOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2FlowableOpt2.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2FlowableOpt2.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2FlowableOpt3.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2FlowableOpt3.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2Observable.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2Observable.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2ObservableBeta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2ObservableBeta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2ObservableOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2ObservableOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2ParallelOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava2ParallelOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava3FlowableOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava3FlowableOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava3ObservableOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava3ObservableOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava3ParallelDiag.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava3ParallelDiag.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava3ParallelOpt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithRxJava3ParallelOpt.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithStreams.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithStreams.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithStreamsBeta.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/akarnokd/akarnokd-misc/15bc6af86cace02ba1013ed9fd8c165d1de1f462/src/jmh/java/hu/akarnokd/comparison/scrabble/ShakespearePlaysScrabbleWithStreamsBeta.java -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/queue/ExamplePerf.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2015-2017 David Karnok 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in 5 | * compliance with the License. You may obtain a copy of the License at 6 | * 7 | * http://www.apache.org/licenses/LICENSE-2.0 8 | * 9 | * Unless required by applicable law or agreed to in writing, software distributed under the License is 10 | * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See 11 | * the License for the specific language governing permissions and limitations under the License. 12 | */ 13 | 14 | package hu.akarnokd.queue; 15 | 16 | import java.util.concurrent.TimeUnit; 17 | 18 | import org.openjdk.jmh.annotations.*; 19 | 20 | @BenchmarkMode(Mode.Throughput) 21 | @Warmup(iterations = 5) 22 | @Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS) 23 | @OutputTimeUnit(TimeUnit.SECONDS) 24 | @Fork(value = 1) 25 | @State(Scope.Thread) 26 | public class ExamplePerf { 27 | @Param({ "1", "1000", "1000000" }) 28 | public int times; 29 | 30 | } -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/reactive/comparison/consumers/PerfRxSingleSubscriber.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactive.comparison.consumers; 2 | 3 | import org.openjdk.jmh.infra.Blackhole; 4 | 5 | public final class PerfRxSingleSubscriber extends rx.SingleSubscriber { 6 | 7 | final Blackhole bh; 8 | 9 | public PerfRxSingleSubscriber(Blackhole bh) { 10 | this.bh = bh; 11 | } 12 | 13 | @Override 14 | public void onError(Throwable e) { 15 | bh.consume(e); 16 | } 17 | 18 | @Override 19 | public void onSuccess(Object t) { 20 | bh.consume(t); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /src/jmh/java/hu/akarnokd/reactive/comparison/consumers/PerfRxSubscriber.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactive.comparison.consumers; 2 | 3 | import org.openjdk.jmh.infra.Blackhole; 4 | 5 | public final class PerfRxSubscriber extends rx.Subscriber { 6 | 7 | final Blackhole bh; 8 | 9 | public PerfRxSubscriber(Blackhole bh) { 10 | this.bh = bh; 11 | } 12 | 13 | @Override 14 | public void onStart() { 15 | bh.consume(true); 16 | } 17 | 18 | @Override 19 | public void onCompleted() { 20 | bh.consume(false); 21 | } 22 | 23 | @Override 24 | public void onError(Throwable e) { 25 | bh.consume(e); 26 | } 27 | 28 | @Override 29 | public void onNext(Object t) { 30 | bh.consume(t); 31 | } 32 | 33 | } 34 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/asyncenum/IAsyncEnumerable.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2016-2018 David Karnok 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in 5 | * compliance with the License. You may obtain a copy of the License at 6 | * 7 | * http://www.apache.org/licenses/LICENSE-2.0 8 | * 9 | * Unless required by applicable law or agreed to in writing, software distributed under the License is 10 | * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See 11 | * the License for the specific language governing permissions and limitations under the License. 12 | */ 13 | package hu.akarnokd.asyncenum; 14 | 15 | public interface IAsyncEnumerable { 16 | 17 | IAsyncEnumerator enumerator(); 18 | } 19 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/asyncenum/IAsyncEnumerator.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright 2016-2018 David Karnok 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in 5 | * compliance with the License. You may obtain a copy of the License at 6 | * 7 | * http://www.apache.org/licenses/LICENSE-2.0 8 | * 9 | * Unless required by applicable law or agreed to in writing, software distributed under the License is 10 | * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See 11 | * the License for the specific language governing permissions and limitations under the License. 12 | */ 13 | 14 | package hu.akarnokd.asyncenum; 15 | 16 | import java.util.concurrent.CompletionStage; 17 | 18 | import rx.subscriptions.CompositeSubscription; 19 | 20 | public interface IAsyncEnumerator { 21 | 22 | CompletionStage moveNext(CompositeSubscription token); 23 | 24 | T current(); 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/enumerables/BasicEnumerator.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.enumerables; 2 | 3 | abstract class BasicEnumerator implements IEnumerator { 4 | 5 | protected T value; 6 | 7 | @Override 8 | public final T current() { 9 | return value; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/enumerables/IEFromCharSequence.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.enumerables; 2 | 3 | final class IEFromCharSequence implements IEnumerable { 4 | 5 | final CharSequence cs; 6 | 7 | IEFromCharSequence(CharSequence cs) { 8 | this.cs = cs; 9 | } 10 | 11 | @Override 12 | public IEnumerator enumerator() { 13 | return new FromCharSequenceEnumerator(cs); 14 | } 15 | 16 | static final class FromCharSequenceEnumerator extends BasicEnumerator { 17 | final CharSequence cs; 18 | 19 | int index; 20 | 21 | FromCharSequenceEnumerator(CharSequence cs) { 22 | this.cs = cs; 23 | } 24 | 25 | @Override 26 | public boolean moveNext() { 27 | int i = index; 28 | CharSequence localCs = cs; 29 | if (i != localCs.length()) { 30 | value = (int)localCs.charAt(i); 31 | index = i + 1; 32 | return true; 33 | } 34 | value = null; 35 | return false; 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/enumerables/IEFromIterable.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.enumerables; 2 | 3 | import java.util.Iterator; 4 | 5 | final class IEFromIterable implements IEnumerable { 6 | 7 | final Iterable source; 8 | 9 | IEFromIterable(Iterable source) { 10 | this.source = source; 11 | } 12 | 13 | @Override 14 | public IEnumerator enumerator() { 15 | return new FromIterableEnumerator<>(source.iterator()); 16 | } 17 | 18 | static final class FromIterableEnumerator extends BasicEnumerator { 19 | 20 | final Iterator source; 21 | 22 | FromIterableEnumerator(Iterator source) { 23 | this.source = source; 24 | } 25 | 26 | @Override 27 | public boolean moveNext() { 28 | if (source.hasNext()) { 29 | value = source.next(); 30 | return true; 31 | } 32 | value = null; 33 | return false; 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/enumerables/IEJust.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.enumerables; 2 | 3 | import io.reactivex.internal.fuseable.ScalarCallable; 4 | 5 | final class IEJust implements IEnumerable, ScalarCallable { 6 | 7 | final T value; 8 | 9 | IEJust(T value) { 10 | this.value = value; 11 | } 12 | 13 | @Override 14 | public T call() { 15 | return value; 16 | } 17 | 18 | @Override 19 | public IEnumerator enumerator() { 20 | return new JustEnumerator<>(value); 21 | } 22 | 23 | static final class JustEnumerator extends BasicEnumerator { 24 | 25 | boolean once; 26 | 27 | JustEnumerator(T value) { 28 | this.value = value; 29 | } 30 | 31 | @Override 32 | public boolean moveNext() { 33 | if (!once) { 34 | once = true; 35 | return true; 36 | } 37 | value = null; 38 | return false; 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/enumerables/IEnumerator.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.enumerables; 2 | 3 | public interface IEnumerator { 4 | 5 | boolean moveNext(); 6 | 7 | T current(); 8 | } 9 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/fallout76/Ba2FileEntry.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.fallout76; 2 | 3 | public final class Ba2FileEntry { 4 | public String name; 5 | public long offset; 6 | public int size; 7 | public byte[] data; 8 | } -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/fallout76/Fallout76LootGenerator.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.fallout76; 2 | 3 | /** 4 | * Simulate loot drops by generating Fallout 76 items and 5 | * collect statistics. 6 | * Much faster than RNG-76 as it doesn't have to render. 7 | */ 8 | public class Fallout76LootGenerator { 9 | 10 | } 11 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/fallout76/old/package-info.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.fallout76.old; -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/io/LongClass.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.io; 2 | import java.lang.reflect.Method; 3 | import java.util.*; 4 | 5 | import io.reactivex.Observable; 6 | 7 | public final class LongClass { 8 | private LongClass() { } 9 | public static void main(String[] args) { 10 | System.out.println("public class ManyMethods {"); 11 | 12 | Method[] ms = Observable.class.getDeclaredMethods(); 13 | 14 | Set names = new HashSet<>(); 15 | 16 | for (int i = 0; i < ms.length; i++) { 17 | if (names.add(ms[i].getName())) { 18 | System.out.println(" public static int " + ms[i].getName() + "(int i) { return i + " + i + "; }"); 19 | } 20 | } 21 | 22 | System.out.println(" public static void main(String[] args) {"); 23 | int i = 0; 24 | for (String s : names) { 25 | if (i % 3 == 0) { 26 | System.out.println(" " + s + "(0);"); 27 | } 28 | i++; 29 | } 30 | System.out.println(" }"); 31 | 32 | System.out.println("}"); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/iterables/SingletonIterator.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.iterables; 2 | 3 | import java.util.*; 4 | import java.util.function.Supplier; 5 | 6 | @FunctionalInterface 7 | public interface SingletonIterator extends Iterator, Supplier[]> { 8 | 9 | @SuppressWarnings("unchecked") 10 | static SingletonIterator of(E e) { 11 | Supplier[] a = new Supplier[] { () -> e }; 12 | return () -> a; 13 | } 14 | 15 | static Supplier none() { 16 | return () -> { throw new NoSuchElementException(); }; 17 | } 18 | 19 | @Override 20 | default boolean hasNext() { 21 | return get()[0] != none(); 22 | } 23 | 24 | @Override 25 | default E next() { 26 | Supplier current = get()[0]; 27 | get()[0] = none(); 28 | return current.get(); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/iterables/SingletonIteratorBugged.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.iterables; 2 | 3 | import java.util.*; 4 | import java.util.function.Supplier; 5 | 6 | @FunctionalInterface 7 | public interface SingletonIteratorBugged extends Iterator, Supplier[]> { 8 | 9 | @SuppressWarnings("unchecked") 10 | static SingletonIteratorBugged of(E e) { 11 | return () -> new Supplier[] { () -> e }; 12 | } 13 | 14 | static Supplier none() { 15 | return () -> { throw new NoSuchElementException(); }; 16 | } 17 | 18 | @Override 19 | default boolean hasNext() { 20 | return get()[0] == none(); 21 | } 22 | 23 | @Override 24 | default E next() { 25 | Supplier current = get()[0]; 26 | get()[0] = none(); 27 | return current.get(); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/A.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.function.Function; 4 | 5 | public final class A { 6 | 7 | private A() { } 8 | 9 | interface C { 10 | 11 | } 12 | 13 | interface O { 14 | Object r(C s); 15 | } 16 | 17 | static O m(O source, Function> mapper) { 18 | return o -> { 19 | class D { 20 | class E { 21 | 22 | } 23 | 24 | E e = new E(); 25 | } 26 | 27 | D d = new D(); 28 | 29 | return d.e; 30 | }; 31 | } 32 | 33 | public static void main(String[] args) { 34 | m(null, null); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/AllCombinations.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class AllCombinations { 7 | 8 | static void AddCombination(List> source, int depth, 9 | String prefix, List output) { 10 | for (String layer : source.get(depth)) { 11 | String str = prefix + layer; 12 | if (depth < source.size() - 1) { 13 | AddCombination(source, depth + 1, str, output); 14 | } else { 15 | output.add(str); 16 | } 17 | } 18 | } 19 | 20 | public static void main(String[] args) { 21 | List> source = List.of( 22 | List.of("a", "b"), 23 | List.of("A", "B", "C"), 24 | List.of("1", "2", "3", "4")); 25 | 26 | List output = new ArrayList<>(); 27 | 28 | AddCombination(source, 0, "", output); 29 | 30 | output.forEach(System.out::println); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/BrInExtraNewLine.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | 7 | public class BrInExtraNewLine { 8 | 9 | public static void main(String[] args) throws IOException { 10 | BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); 11 | in.readLine(); 12 | System.out.println("Enter value:"); 13 | String s = in.readLine(); 14 | System.out.println((int)(s.charAt(0))); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/Bug20216.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.function.Consumer; 4 | 5 | public class Bug20216 { 6 | static Consumer compileError() { 7 | return v -> { 8 | /* 9 | class Z implements Consumer { 10 | @Override 11 | public void accept(T t) { 12 | 13 | } 14 | } 15 | */ 16 | }; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/Button45.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.awt.Robot; 4 | import java.awt.event.MouseEvent; 5 | 6 | public class Button45 { 7 | 8 | public static void main(String[] args) throws Exception { 9 | Robot robot = new Robot(); 10 | 11 | Thread.sleep(5000); 12 | 13 | robot.mousePress(MouseEvent.getMaskForButton(4)); 14 | 15 | Thread.sleep(200); 16 | 17 | robot.mouseRelease(MouseEvent.getMaskForButton(4)); 18 | 19 | Thread.sleep(5000); 20 | 21 | robot.mousePress(MouseEvent.getMaskForButton(5)); 22 | 23 | Thread.sleep(200); 24 | 25 | robot.mouseRelease(MouseEvent.getMaskForButton(5)); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/CP037.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import org.apache.commons.codec.binary.Hex; 4 | 5 | public class CP037 { 6 | 7 | public static void main(String[] args) throws Exception { 8 | String hexstring = Integer.toHexString((short) 5565).trim(); 9 | System.out.println(hexstring); 10 | byte[] bytes = Hex.decodeHex(hexstring); 11 | String result = new String(bytes,"CP037"); 12 | System.out.println(result); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/DigitSwapper.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.*; 4 | 5 | public class DigitSwapper { 6 | 7 | public static void main(String[] args) { 8 | List results = new ArrayList<>(); 9 | 10 | for (long j = 11; j < 16_000_000_000L; j++) { 11 | long lastDigit = j % 10; 12 | long shiftedValue = j / 10; 13 | long remainder = shiftedValue; 14 | while (remainder > 9) { 15 | remainder /= 10; 16 | lastDigit *= 10; 17 | } 18 | lastDigit *= 10; 19 | 20 | long newValue = lastDigit + shiftedValue; 21 | 22 | if (j * 2 == newValue) { 23 | System.out.println(j); 24 | results.add(j); 25 | } 26 | if (j % 10_000_000 == 0) { 27 | System.out.println(">> " + j); 28 | } 29 | } 30 | System.out.println("---------"); 31 | results.forEach(System.out::println); 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/ExpandKeysInMap.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.HashMap; 4 | import java.util.List; 5 | import java.util.Map; 6 | import java.util.stream.Collectors; 7 | 8 | public class ExpandKeysInMap { 9 | 10 | public static void main(String[] args) { 11 | Map, String> map = new HashMap<>(); 12 | map.put(List.of("A", "B"), "X"); 13 | map.put(List.of("C"), "Y"); 14 | 15 | var result = map.entrySet() 16 | .stream() 17 | .flatMap(kv -> kv.getKey().stream().map(k -> Map.entry(k, kv.getValue()))) 18 | .collect(Collectors.toMap(k -> k.getKey(), v -> v.getValue())); 19 | 20 | result.entrySet().forEach(System.out::println); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/Finput.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.FileInputStream; 5 | import java.io.IOException; 6 | import java.io.InputStreamReader; 7 | import java.nio.charset.StandardCharsets; 8 | import java.nio.file.Paths; 9 | 10 | import reactor.core.Exceptions; 11 | import reactor.core.publisher.Flux; 12 | 13 | public class Finput { 14 | 15 | public static void main(String[] args) { 16 | var ipPath = Paths.get(""); 17 | Flux.using(() -> new FileInputStream(ipPath.toFile()), 18 | fileInputStream -> { 19 | final var isr = new InputStreamReader(fileInputStream, StandardCharsets.UTF_8); 20 | final var bufferReader = new BufferedReader(isr); 21 | return Flux.fromStream(bufferReader.lines()); 22 | }, 23 | is -> { 24 | try { 25 | is.close(); 26 | } catch (IOException ex) { 27 | throw Exceptions.bubble(ex); 28 | } 29 | } 30 | ); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/HasAllLetters.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | public class HasAllLetters { 4 | public static void main(String[] args) 5 | { 6 | boolean alphs[]=new boolean[26]; 7 | int i; 8 | int flag=0; 9 | for(i=0;i<26;i++) 10 | { 11 | alphs[i]=false; 12 | } 13 | String sent="the quick brown fox jumps over the lazy dog"; 14 | sent=sent.toUpperCase(); 15 | sent=sent.replaceAll("\\s",""); 16 | for(i=0;i { } 4 | 5 | class Klass implements C { 6 | Klass(java.util.function.Consumer consumer) { } 7 | } 8 | 9 | public class InferenceError { 10 | 11 | public > E method(E e) { 12 | return e; 13 | } 14 | 15 | static void n() { 16 | /* 17 | InferenceError p = new InferenceError<>(); 18 | java.util.List list = new java.util.ArrayList<>(); 19 | //p.method(new Klass<>(list::add)); 20 | * 21 | */ 22 | } 23 | } 24 | 25 | 26 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/Interfaceoverride.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | public class Interfaceoverride { 4 | 5 | interface A { 6 | void f(String o); 7 | } 8 | 9 | static class B implements A { 10 | @Override 11 | public void f(String o) { 12 | 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/InterfacesC.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | public class InterfacesC { 4 | interface A 5 | { 6 | 7 | void a (); 8 | 9 | void b (); 10 | 11 | void c (); 12 | 13 | void d (); 14 | 15 | } 16 | static abstract class B implements A 17 | { 18 | 19 | public void c () 20 | { 21 | 22 | System.out.println ("I am c"); 23 | 24 | } 25 | 26 | } 27 | static class M extends B 28 | { 29 | 30 | 31 | public void a () 32 | { 33 | 34 | System.out.println ("I am a"); 35 | 36 | } 37 | public void b () 38 | { 39 | 40 | System.out.println ("I am b"); 41 | 42 | } 43 | public void d () 44 | { 45 | 46 | System.out.println ("I am d"); 47 | 48 | } 49 | } 50 | 51 | class Abstract 52 | { 53 | 54 | 55 | public static void main (String[]args) 56 | { 57 | 58 | A a = new M (); 59 | 60 | a.a (); 61 | 62 | a.b (); 63 | 64 | a.c (); 65 | 66 | a.d (); 67 | 68 | } 69 | 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/Lead.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Lead { 6 | public static void main (String[] args) 7 | { 8 | Scanner sc = new Scanner(System.in); 9 | 10 | Boolean checker=true; 11 | int lead1=0,lead2=0,lead = 0; 12 | int rounds = sc.nextInt(); 13 | for(int i=1;i<=rounds;i++){ 14 | int x = sc.nextInt(); 15 | int y = sc.nextInt(); 16 | if(x>y){ 17 | lead1 = x-y; 18 | if(lead1>=lead){ 19 | checker=true; 20 | lead=lead1; 21 | } 22 | } 23 | else if(y>x){ 24 | lead2 = y-x; 25 | if(lead2>=lead){ 26 | checker=false; 27 | lead=lead2; 28 | } 29 | } 30 | } 31 | sc.close(); 32 | if(checker==true){ 33 | System.out.println(1+" "+lead); 34 | } 35 | else if(checker==false){ 36 | System.out.println(2+" "+lead); 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/LongestEventSub.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.Scanner; 4 | 5 | public class LongestEventSub { 6 | public static void main(String[] args) 7 | { 8 | Scanner sc=new Scanner(System.in); 9 | int t=sc.nextInt(); 10 | int j=0; 11 | while(t-->0) 12 | { 13 | int n=sc.nextInt(); 14 | int count=0; 15 | int[] arr=new int[n]; 16 | for(int i=0;i(); 9 | 10 | for (int i = 0; i < list.size(); i = i++) { 11 | map.put(list.get(i), list.get(++i)); 12 | i++; 13 | } 14 | 15 | System.out.println(map); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/MayBy.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.List; 4 | import java.util.TreeMap; 5 | import java.util.stream.Collectors; 6 | 7 | public class MayBy { 8 | 9 | 10 | public static void main(String[] args) { 11 | 12 | record MyObject(int stageNumber, int stageToCalc) { } 13 | 14 | List list = List.of( 15 | new MyObject(2, 1), 16 | new MyObject(5, 1), 17 | new MyObject(9, 7), 18 | new MyObject(10, 7) 19 | ); 20 | 21 | list.stream() 22 | .collect(Collectors.groupingBy(v -> v.stageToCalc, TreeMap::new, Collectors.toList())) 23 | .lastEntry() 24 | .getValue() 25 | .stream() 26 | .collect(Collectors.groupingBy(v -> v.stageNumber, TreeMap::new, Collectors.toList())) 27 | .lastEntry() 28 | .getValue() 29 | .forEach(System.out::println); 30 | ; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/MonoAppended.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.List; 4 | 5 | import reactor.core.publisher.Flux; 6 | import reactor.core.publisher.Mono; 7 | 8 | public class MonoAppended { 9 | public static void main(String[] args) { 10 | 11 | Mono> source = Flux.just("A", "B", "C").collectList(); 12 | 13 | source 14 | .doOnNext(list -> list.add(0, "All")) 15 | .subscribe(System.out::println, Throwable::printStackTrace, () -> System.out.println("Done")); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/NPEPuzzle.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | public class NPEPuzzle { 4 | static volatile NPEPuzzle T = new NPEPuzzle(); 5 | 6 | int n; 7 | 8 | public static void main(String[] args) { 9 | while (true) { 10 | NPEPuzzle a = T, b = T, c = T, d = T; 11 | a.n = b.n = c.n = d.n; 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/OpenFromDesktop.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.io.File; 4 | 5 | import javax.imageio.ImageIO; 6 | 7 | public class OpenFromDesktop { 8 | 9 | public static void main(String[] args) throws Exception { 10 | ImageIO.read(new File("c:/users/akarnokd/desktop/image.png")); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/ParallelSum.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.List; 4 | import java.util.stream.Collectors; 5 | 6 | public class ParallelSum { 7 | 8 | public static void main(String[] args) { 9 | List.of(1, 2, 3, 4, 5) 10 | .parallelStream() 11 | .collect(Collectors.summingInt(v -> v)); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/ProcessCommands.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | public class ProcessCommands { 4 | 5 | public static void main(String[] args) { 6 | ProcessBuilder pb = new ProcessBuilder("cmd"); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/Recolor.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.awt.image.BufferedImage; 4 | import java.io.*; 5 | 6 | import javax.imageio.ImageIO; 7 | 8 | public class Recolor { 9 | 10 | public static void main(String[] args) throws IOException { 11 | File f = new File("c:\\Users\\akarnokd\\git\\digiprime-pcp-webservice\\src\\main\\webapp\\bar-chart-h.png "); 12 | BufferedImage img = ImageIO.read(f); 13 | 14 | for (int y = 0; y < img.getHeight(); y++) { 15 | for (int x = 0; x < img.getWidth(); x++) { 16 | int color = img.getRGB(x, y); 17 | int newColor = (color & 0xFF000000) | (0xA0A2A2); 18 | img.setRGB(x, y, newColor); 19 | } 20 | } 21 | 22 | ImageIO.write(img, "png", f); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/RecordVarargs.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | public class RecordVarargs { 4 | 5 | public static void main(String[] args) { 6 | record Strings(String... str) { } 7 | 8 | System.out.println(new Strings("A", "B")); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/ScannerNext.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.Scanner; 4 | 5 | public class ScannerNext { 6 | 7 | public static void main(String[] args) { 8 | Scanner scan = new Scanner(System.in); 9 | 10 | try { 11 | System.out.println(scan.nextInt()); 12 | } catch (Exception ex) { 13 | System.out.println("Wrong input"); 14 | System.out.println(scan.next()); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/Scansort.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class Scansort { 7 | public static void insertionSort(int array[]) { 8 | int arrayLength = array.length; 9 | 10 | for (int i = 1; i < arrayLength; i++) { 11 | int key = array[i]; 12 | int j = i - 1; 13 | 14 | while (j >= 0 && key < array[j]) { 15 | array[j + 1] = array[j]; 16 | j--; 17 | } 18 | array[j + 1] = key; 19 | } 20 | } 21 | 22 | public static void main(String args[]) { 23 | 24 | int length = 10; //arraylength 25 | int k= 0; 26 | int array[] = new int[length]; 27 | 28 | Scanner input = new Scanner(System.in); 29 | System.out.print("Please write the array elements : "); 30 | 31 | for (k = 0; k < array.length; k++){ 32 | array[k] = input.nextInt(); 33 | } 34 | 35 | insertionSort(array); 36 | 37 | System.out.print ("Sorted array : "); 38 | System.out.println(Arrays.toString(array)); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/SimpleDateAdd.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.text.ParseException; 4 | import java.text.SimpleDateFormat; 5 | import java.util.Calendar; 6 | 7 | public class SimpleDateAdd { 8 | 9 | public static void main(String[] args) { 10 | String pickupdate = "06-30-2022"; 11 | SimpleDateFormat sdf = new SimpleDateFormat("MM-dd-yyyy"); 12 | 13 | Calendar c = Calendar.getInstance(); 14 | try { 15 | c.setTime(sdf.parse(pickupdate)); 16 | } catch (ParseException e){ 17 | e.printStackTrace(); 18 | } 19 | 20 | c.add(Calendar.DAY_OF_MONTH, 3); 21 | String expirydate= sdf.format(c.getTime()); 22 | 23 | System.out.println(expirydate); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/SmallJPEG.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.io.File; 4 | 5 | import javax.imageio.ImageIO; 6 | 7 | public class SmallJPEG { 8 | public static void main(String[] args) throws Exception { 9 | ImageIO.read(new File("c:\\Users\\akarnokd\\Downloads\\cmlyI.jpg")); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/SplitNKeep.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.util.Arrays; 4 | import java.util.regex.Pattern; 5 | 6 | public class SplitNKeep { 7 | 8 | public static void main(String[] args) { 9 | String currency = "$"; // from your method 10 | 11 | String escapedCurrency = Pattern.quote(currency); 12 | 13 | String[] result = "$5".split(escapedCurrency, 2); 14 | result[0] = currency; 15 | 16 | System.out.println(Arrays.toString(result)); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/TaxiCount.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | public class TaxiCount { 4 | 5 | public static void main(String[] args) { 6 | 7 | } 8 | 9 | } 10 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/UseSiteTypeAnnot.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | import java.lang.annotation.*; 4 | 5 | import io.reactivex.Observable; 6 | import io.reactivex.functions.Function; 7 | 8 | public class UseSiteTypeAnnot { 9 | 10 | public Observable map(Function<@NN T, @NN R> mapper) { 11 | return null; 12 | } 13 | } 14 | 15 | @Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER}) 16 | @interface NN { 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/misc/UserHome.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.misc; 2 | 3 | public class UserHome { 4 | 5 | public static void main(String[] args) { 6 | System.out.println(System.getProperty("user.home")); 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/queue/IQueue.java: -------------------------------------------------------------------------------- 1 | // This is used to simplify the code for the Stress tests and performance tests 2 | package hu.akarnokd.queue; 3 | 4 | public interface IQueue { 5 | public void enqueue(E item); 6 | public E dequeue(); 7 | } -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/reactive/lowalloc/LcObservable.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactive.lowalloc; 2 | 3 | import java.util.function.Function; 4 | 5 | import io.reactivex.Observer; 6 | 7 | public abstract class LcObservable { 8 | 9 | public abstract void subscribe(Observer observer); 10 | 11 | public static LcObservable just(T value) { 12 | return new LcObservableJust(value); 13 | } 14 | 15 | public static LcObservable range(int start, int count) { 16 | if (count == 1) { 17 | return just(start); 18 | } 19 | return new LcObservableRange(start, start + count); 20 | } 21 | 22 | public final LcObservable map(Function mapper) { 23 | return new LcObservableMap(this, mapper); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/reactive/lowalloc/LcObservableJust.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactive.lowalloc; 2 | 3 | import io.reactivex.Observer; 4 | 5 | final class LcObservableJust extends LcSourceObservable { 6 | 7 | final T value; 8 | 9 | volatile boolean disposed; 10 | 11 | LcObservableJust(T value) { 12 | this.value = value; 13 | } 14 | 15 | @Override 16 | protected LcSourceObservable createFresh() { 17 | return new LcObservableJust(value); 18 | } 19 | 20 | @Override 21 | public void dispose() { 22 | disposed = true; 23 | } 24 | 25 | @Override 26 | public boolean isDisposed() { 27 | return disposed; 28 | } 29 | 30 | @Override 31 | protected void subscribeActual(Observer downstream) { 32 | downstream.onSubscribe(this); 33 | 34 | if (disposed) { 35 | return; 36 | } 37 | downstream.onNext(value); 38 | if (disposed) { 39 | return; 40 | } 41 | downstream.onComplete(); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/reactive/lowalloc/LcSourceObservable.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactive.lowalloc; 2 | 3 | import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; 4 | 5 | import io.reactivex.Observer; 6 | import io.reactivex.disposables.Disposable; 7 | 8 | public abstract class LcSourceObservable extends LcObservable implements Disposable { 9 | 10 | volatile int sourceState; 11 | 12 | @SuppressWarnings("rawtypes") 13 | static final AtomicIntegerFieldUpdater SOURCE_STATE = 14 | AtomicIntegerFieldUpdater.newUpdater(LcSourceObservable.class, "sourceState"); 15 | 16 | protected abstract void subscribeActual(Observer downstream); 17 | 18 | protected abstract LcSourceObservable createFresh(); 19 | 20 | @Override 21 | public final void subscribe(Observer observer) { 22 | if (sourceState == 0 && SOURCE_STATE.compareAndSet(this, 0, 1)) { 23 | subscribeActual(observer); 24 | } else { 25 | createFresh().subscribeActual(observer); 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/reactive/observables/BooleanDisposable.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactive.observables; 2 | 3 | public final class BooleanDisposable implements IDisposable { 4 | 5 | boolean disposed; 6 | 7 | public boolean isDisposed() { 8 | return disposed; 9 | } 10 | 11 | @Override 12 | public void dispose() { 13 | disposed = true; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/reactive/observables/IDisposable.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactive.observables; 2 | 3 | public interface IDisposable { 4 | 5 | void dispose(); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/reactive/observables/IObserver.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactive.observables; 2 | 3 | public interface IObserver { 4 | 5 | void onSubscribe(IDisposable d); 6 | 7 | void onNext(T element); 8 | 9 | void onError(Throwable cause); 10 | 11 | void onComplete(); 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava/ActionInBetween.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import rx.Observable; 6 | import rx.subjects.PublishSubject; 7 | 8 | public class ActionInBetween { 9 | 10 | public static void main(String[] args) throws Exception { 11 | PublishSubject ps = PublishSubject.create(); 12 | 13 | ps.publish(o -> 14 | o.mergeWith( 15 | o.switchMap(e -> 16 | Observable.just(1).delay(200, TimeUnit.MILLISECONDS) 17 | .ignoreElements() 18 | .doOnCompleted(() -> System.out.println("Timeout action: " + e)) 19 | ) 20 | ) 21 | ).subscribe(System.out::println); 22 | 23 | ps.onNext(1); 24 | ps.onNext(2); 25 | 26 | Thread.sleep(100); 27 | 28 | ps.onNext(3); 29 | 30 | Thread.sleep(250); 31 | 32 | ps.onNext(4); 33 | 34 | Thread.sleep(250); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava/DebounceFirst.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import rx.Observable; 6 | 7 | public final class DebounceFirst { 8 | 9 | private DebounceFirst() { } 10 | 11 | public static void main(String[] args) { 12 | Observable.just(0, 100, 200, 1500, 1600, 1800, 2000, 10000) 13 | .flatMap(v -> Observable.timer(v, TimeUnit.MILLISECONDS).map(w -> v)) 14 | .doOnNext(v -> System.out.println("T=" + v)) 15 | .compose(debounceFirst(500, TimeUnit.MILLISECONDS)) 16 | .toBlocking() 17 | .subscribe(v -> System.out.println("Debounced: " + v)); 18 | } 19 | 20 | static Observable.Transformer debounceFirst(long timeout, TimeUnit unit) { 21 | return f -> 22 | f.publish(g -> 23 | g.take(1) 24 | .concatWith( 25 | g.switchMap(u -> Observable.timer(timeout, unit).map(w -> u)) 26 | .take(1) 27 | .ignoreElements() 28 | ) 29 | .repeatWhen(h -> h.takeUntil(g.ignoreElements())) 30 | ) 31 | ; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava/EmitterTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import rx.*; 4 | import rx.schedulers.Schedulers; 5 | 6 | public final class EmitterTest { 7 | private EmitterTest() { } 8 | public static void main(String[] args) { 9 | Observable obs = Observable.create(emitter -> { 10 | for (int i = 1; i < 1000; i++) { 11 | if (i % 5 == 0) { 12 | sleep(300L); 13 | } 14 | 15 | emitter.onNext(i); 16 | } 17 | 18 | emitter.onCompleted(); 19 | }, Emitter.BackpressureMode.LATEST); 20 | 21 | obs.subscribeOn(Schedulers.computation()) 22 | .observeOn(Schedulers.computation()) 23 | .toBlocking() 24 | .subscribe(value -> System.out.println("Received " + value)); // Why does this get stuck at "Received 128" 25 | 26 | // sleep(10000L); 27 | } 28 | 29 | private static void sleep(long duration) { 30 | try { 31 | Thread.sleep(duration); 32 | } catch (InterruptedException e) { 33 | throw new RuntimeException(e); 34 | } 35 | } 36 | } -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava/Example.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | public final class Example { 3 | 4 | private Example() { } 5 | 6 | static String str; 7 | 8 | public static void main(String[] args) { 9 | str = "aaa"; 10 | 11 | String local = str; 12 | 13 | str = "ggg"; 14 | 15 | System.out.println(local); 16 | System.out.println(local); 17 | System.out.println(local); 18 | } 19 | } -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava/GroupByTest2.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | import static rx.Observable.range; 3 | 4 | import java.util.Random; 5 | 6 | import rx.Observable; 7 | import rx.schedulers.Schedulers; 8 | 9 | public final class GroupByTest2 { 10 | private GroupByTest2() { } 11 | 12 | public static void main(String[] args) throws Exception { 13 | Observable source = range(1, 10000); 14 | source 15 | .doOnRequest(i -> System.out.println("Requested " + i)) 16 | .groupBy(v -> v % 5) 17 | .flatMap(g -> g.observeOn(Schedulers.io()).map(GroupByTest2::calculation), 4) 18 | .subscribe(i -> System.out.println("Got " + i)); 19 | Thread.sleep(100000); 20 | } 21 | 22 | private static Integer calculation(Integer i) { 23 | sleep(); 24 | System.out.println("Processing " + i); 25 | return i * 20; 26 | } 27 | 28 | private static void sleep() { 29 | try { 30 | Thread.sleep(new Random().nextInt(1000)); 31 | } catch (InterruptedException e) { 32 | e.printStackTrace(); 33 | } 34 | } 35 | } -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava/Merge4691.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import rx.Observable; 4 | import rx.schedulers.Schedulers; 5 | 6 | public final class Merge4691 { 7 | private Merge4691() { } 8 | public static void main(String[] args) { 9 | Observable o1 = Observable.just(1, 2, 3); 10 | Observable o2 = Observable.merge( 11 | o1, 12 | Observable.empty() 13 | ) 14 | .subscribeOn(Schedulers.newThread()) 15 | .doOnCompleted(() -> error("a")); 16 | Observable o3 = Observable.just(4, 5, 6); 17 | Observable o4 = Observable.merge( 18 | o3, 19 | Observable.empty() 20 | ) 21 | .subscribeOn(Schedulers.newThread()) 22 | .doOnCompleted(() -> error("b")); 23 | Observable.merge( 24 | o2, 25 | o4 26 | ) 27 | .doOnCompleted(() -> error("c")) 28 | .subscribe(); 29 | } 30 | 31 | static void error(String s) { 32 | System.err.println(s); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava/ShareLatest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import rx.Observable; 6 | import rx.schedulers.Schedulers; 7 | 8 | public final class ShareLatest { 9 | 10 | private ShareLatest() { 11 | 12 | } 13 | 14 | public static void main(String[] args) { 15 | System.out.println(Observable.interval(1, 1, TimeUnit.MILLISECONDS) 16 | .take(2000) 17 | .share() 18 | .onBackpressureLatest() 19 | .subscribeOn(Schedulers.io()) 20 | .observeOn(Schedulers.computation(), 16) 21 | .doOnNext(System.out::println) 22 | .toList() 23 | .toBlocking() 24 | .last().size()); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava/SingleAsync.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import rx.Single; 6 | 7 | public class SingleAsync { 8 | 9 | public static void main(String[] args) throws Exception { 10 | Single.just("test") 11 | .delay(1, TimeUnit.MILLISECONDS) 12 | .subscribe( 13 | result -> { 14 | System.out.println("got text: " + result); 15 | throw new IllegalStateException("single async something is wrong"); 16 | // onError will not be called, hard crash 17 | }, 18 | e -> { 19 | // not called 20 | System.out.println("caught error " + e.getMessage()); 21 | e.printStackTrace(); 22 | }); 23 | 24 | Thread.sleep(2000); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava/ThrottleFirstExample.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import rx.Observable; 6 | 7 | public final class ThrottleFirstExample { 8 | private ThrottleFirstExample() { } 9 | 10 | public static void main(String[] args) { 11 | Observable.just(100, 2000, 3000, 6000, 7000, 10000) 12 | .flatMap(time -> Observable.timer(time, TimeUnit.MILLISECONDS).map(v -> time)) 13 | .throttleFirst(4000, TimeUnit.MILLISECONDS) 14 | .toBlocking() 15 | .forEach(System.out::println); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/BufferSkipAsync.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import io.reactivex.Observable; 4 | import io.reactivex.subjects.*; 5 | import ix.Ix; 6 | 7 | public class BufferSkipAsync { 8 | 9 | public static void main(String[] args) { 10 | 11 | Subject rp = PublishSubject.create().toSerialized(); 12 | 13 | Observable share = rp.share(); 14 | 15 | int numPrevious = 2; 16 | 17 | share.buffer(numPrevious, 1) 18 | .filter(b -> b.size() < numPrevious || b.get(numPrevious - 1) >= 3) 19 | .map(v -> v.get(0)) 20 | .subscribe(System.out::println); 21 | 22 | Ix.range(1, 10).foreach(rp::onNext); 23 | rp.onComplete(); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/Counts.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import io.reactivex.Flowable; 4 | import reactor.core.publisher.Flux; 5 | 6 | public final class Counts { 7 | 8 | private Counts() { } 9 | 10 | public static void main(String[] args) { 11 | Flowable.fromArray(Flowable.class.getMethods()) 12 | .filter(m -> m.getDeclaringClass() == Flowable.class) 13 | .map(m -> m.getName()) 14 | .distinct() 15 | .count() 16 | .subscribe(System.out::println); 17 | 18 | Flowable.fromArray(Flux.class.getMethods()) 19 | .filter(m -> m.getDeclaringClass() == Flux.class) 20 | .map(m -> m.getName()) 21 | .distinct() 22 | .count() 23 | .subscribe(System.out::println); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/DoOnErrorFusion.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import io.reactivex.Flowable; 4 | import io.reactivex.flowables.ConnectableFlowable; 5 | 6 | public class DoOnErrorFusion { 7 | 8 | public static void main(String[] args) { 9 | ConnectableFlowable f = Flowable.just(1) 10 | .doOnNext(i -> { 11 | throw new IllegalArgumentException(); 12 | }) 13 | .doOnError(e -> { 14 | throw new IllegalStateException(e); 15 | }).publish(); 16 | f.subscribe( 17 | i -> { throw new AssertionError(); }, 18 | e -> e.printStackTrace()); 19 | f.connect(); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/EIsNotNull.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import io.reactivex.*; 4 | import rx.Single; 5 | 6 | public class EIsNotNull { 7 | 8 | public static void main(String[] args) { 9 | 10 | Single.create(e -> System.out.println(e == null)).subscribe(); 11 | 12 | Maybe.create(e -> System.out.println(e == null)).subscribe(); 13 | 14 | Completable.create(e -> System.out.println(e == null)).subscribe(); 15 | 16 | Flowable.create(e -> System.out.println(e == null), BackpressureStrategy.MISSING).subscribe(); 17 | 18 | Observable.create(e -> System.out.println(e == null)).subscribe(); 19 | 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/FlowVsRS.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | public class FlowVsRS { 4 | 5 | interface FlowPublisher { 6 | 7 | } 8 | 9 | interface RSPublisher extends FlowPublisher { 10 | 11 | } 12 | 13 | public static void flowAPI(FlowPublisher src) { 14 | 15 | } 16 | 17 | public static void rsAPI(RSPublisher src) { 18 | 19 | } 20 | 21 | public static void main(String[] args) { 22 | flowAPI(new FlowPublisher() { }); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/InsertHeader.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.*; 4 | 5 | import io.reactivex.Observable; 6 | 7 | public class InsertHeader { 8 | 9 | public static void main(String[] args) { 10 | Observable.just(1, 3, 4, 5, 7, 8, 10, 12, 14) 11 | .buffer(2, 1) 12 | .flatMapIterable(v -> { 13 | if (v.size() <= 1) { 14 | return v; 15 | } 16 | if (v.get(1) - v.get(0) > 1) { 17 | return Arrays.asList(v.get(0), 1000); 18 | } 19 | return Collections.singletonList(v.get(0)); 20 | }) 21 | .subscribe(System.out::println); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/IntDeferredReducerCore.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.reactivestreams.Subscription; 4 | 5 | import reactor.core.CoreSubscriber; 6 | 7 | public abstract class IntDeferredReducerCore extends DeferredScalarSubscriber 8 | implements CoreSubscriber { 9 | 10 | Subscription s; 11 | 12 | int accumulator; 13 | 14 | boolean hasValue; 15 | 16 | public IntDeferredReducerCore(CoreSubscriber actual) { 17 | super(actual); 18 | } 19 | 20 | @Override 21 | public final void onSubscribe(Subscription s) { 22 | this.s = s; 23 | 24 | subscriber.onSubscribe(this); 25 | 26 | s.request(Long.MAX_VALUE); 27 | } 28 | 29 | @Override 30 | public final void onError(Throwable t) { 31 | subscriber.onError(t); 32 | } 33 | 34 | @Override 35 | public final void onComplete() { 36 | if (hasValue) { 37 | complete(accumulator); 38 | } else { 39 | subscriber.onComplete(); 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/LongDeferredReducerCore.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.reactivestreams.*; 4 | 5 | public abstract class LongDeferredReducerCore extends DeferredScalarSubscriber 6 | implements Subscriber { 7 | 8 | Subscription s; 9 | 10 | long accumulator; 11 | 12 | boolean hasValue; 13 | 14 | public LongDeferredReducerCore(Subscriber actual) { 15 | super(actual); 16 | } 17 | 18 | @Override 19 | public final void onSubscribe(Subscription s) { 20 | this.s = s; 21 | 22 | subscriber.onSubscribe(this); 23 | 24 | s.request(Long.MAX_VALUE); 25 | } 26 | 27 | @Override 28 | public final void onError(Throwable t) { 29 | subscriber.onError(t); 30 | } 31 | 32 | @Override 33 | public final void onComplete() { 34 | if (hasValue) { 35 | complete(accumulator); 36 | } else { 37 | subscriber.onComplete(); 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/ReduceWhile.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.ArrayList; 4 | 5 | import io.reactivex.Observable; 6 | 7 | public class ReduceWhile { 8 | public static void main(String[] args) { 9 | Observable.range(1, 10) 10 | .scanWith(() -> new ArrayList<>(), (a, b) -> { a.add(b); return a; }) 11 | .takeUntil(a -> a.size() == 5) 12 | .takeLast(1) 13 | .subscribe(System.out::println); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/RefCountGrace.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import io.reactivex.Flowable; 6 | import io.reactivex.schedulers.TestScheduler; 7 | 8 | public class RefCountGrace { 9 | 10 | public static void main(String[] args) { 11 | TestScheduler sch = new TestScheduler(); 12 | 13 | Flowable f = Flowable.just(1).replay(1) 14 | .refCount(1, 10, TimeUnit.MILLISECONDS, sch); 15 | 16 | f.subscribe(); 17 | 18 | sch.advanceTimeBy(10, TimeUnit.MILLISECONDS); 19 | 20 | f.test().assertResult(1); 21 | 22 | sch.advanceTimeBy(10, TimeUnit.MILLISECONDS); 23 | 24 | f.test().assertResult(1); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/RepeatWhenEmpty.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import rx.Observable; 4 | 5 | public class RepeatWhenEmpty { 6 | 7 | public static void main(String[] args) { 8 | Observable.just(1) 9 | .repeatWhen(o -> Observable.empty()) 10 | .subscribe(System.out::println); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/ShiftByCount.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import io.reactivex.Flowable; 6 | 7 | public class ShiftByCount { 8 | 9 | public static void main(String[] args) { 10 | Flowable.range(1, 7) 11 | .flatMap(v -> Flowable.timer(v * 200, TimeUnit.MILLISECONDS).map(w -> v)) 12 | .doOnNext(v -> System.out.println(v)) 13 | .publish(f -> 14 | f.skip(3).zipWith(f, (a, b) -> b).mergeWith(f.takeLast(3)) 15 | ) 16 | .blockingSubscribe(v -> System.out.println("<-- " + v)) 17 | ; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/SubscribeOnFalse.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import io.reactivex.Flowable; 4 | import io.reactivex.schedulers.Schedulers; 5 | 6 | public class SubscribeOnFalse { 7 | 8 | public static void main(String[] args) { 9 | Flowable.range(1, 10) 10 | .subscribeOn(Schedulers.io(), true) 11 | .doOnNext(v -> System.out.println(Thread.currentThread().getName())) 12 | .observeOn(Schedulers.single(), false, 1) 13 | .blockingSubscribe(); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/TrampolineInfinite.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import io.reactivex.Observable; 6 | import io.reactivex.schedulers.Schedulers; 7 | 8 | public class TrampolineInfinite { 9 | 10 | public static void main(String[] args) throws Exception { 11 | System.out.println("start"); 12 | // snippt-1 13 | Observable.intervalRange(0L, 10L, 1, 1, TimeUnit.SECONDS, Schedulers.trampoline()) 14 | .subscribe(aLong -> System.out.println(aLong + "; " + Thread.currentThread().getName()), Throwable::printStackTrace, 15 | () -> System.out.println("complete1.")); 16 | // snippt-2 17 | Observable.interval(1, TimeUnit.SECONDS, Schedulers.trampoline()).take(10) 18 | .subscribe(aLong -> System.out.println(aLong + "; " + Thread.currentThread().getName()), Throwable::printStackTrace, 19 | () -> System.out.println("complete2.")); 20 | 21 | Thread.sleep(30000); 22 | System.out.println("end"); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava2/Transformers.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.reactivestreams.Publisher; 4 | 5 | import io.reactivex.*; 6 | 7 | public class Transformers implements FlowableTransformer, ObservableTransformer { 8 | 9 | @Override 10 | public ObservableSource apply(Observable upstream) { 11 | // TODO Auto-generated method stub 12 | return null; 13 | } 14 | 15 | @Override 16 | public Publisher apply(Flowable upstream) { 17 | // TODO Auto-generated method stub 18 | return null; 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava3/GroupByAbandon.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava3; 2 | 3 | import io.reactivex.rxjava3.core.Flowable; 4 | 5 | public class GroupByAbandon { 6 | 7 | public static void main(String[] args) { 8 | var eventDTOFlowable = Flowable.just( 9 | "item1", 10 | "item2", 11 | "item3", 12 | "item4", 13 | "item5", 14 | "item6" 15 | ); 16 | 17 | var groupedFlowables = eventDTOFlowable 18 | .groupBy(x -> x) 19 | .flatMapSingle(g -> g.toList()) 20 | .toList() 21 | .blockingGet() 22 | ; 23 | System.out.println(groupedFlowables); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/rxjava3/ShareExample.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava3; 2 | 3 | import io.reactivex.rxjava3.core.Observable; 4 | import io.reactivex.rxjava3.observables.ConnectableObservable; 5 | 6 | public class ShareExample { 7 | 8 | public static void main(String[] args) { 9 | ConnectableObservable source = Observable.create(emitter -> { 10 | emitter.onNext("Hello"); 11 | emitter.onNext("Foo"); 12 | emitter.onNext("Bar"); 13 | emitter.onNext("RxJava"); 14 | }).publish(); 15 | 16 | source.subscribe(e -> System.out.println("Observer 1: " + e)); 17 | source.subscribe(e -> System.out.println("Observer 2: " + e)); 18 | 19 | source.connect(); 20 | 21 | Observable source2 = Observable.create(emitter -> { 22 | emitter.onNext("Hello"); 23 | emitter.onNext("Foo"); 24 | emitter.onNext("Bar"); 25 | emitter.onNext("RxJava"); 26 | }).publish().refCount(2); 27 | 28 | source2.subscribe(e -> System.out.println("Observer 1: " + e)); 29 | source2.subscribe(e -> System.out.println("Observer 2: " + e)); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/starfield/Crafter.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.starfield; 2 | 3 | import java.awt.Robot; 4 | import java.awt.event.*; 5 | 6 | public class Crafter { 7 | 8 | public static void main(String[] args) throws Exception { 9 | Robot robot = new Robot(); 10 | 11 | robot.setAutoDelay(15); 12 | 13 | int delay = 15; 14 | for (int i = 0; i < delay; i++) { 15 | System.out.println("Begin in " + (delay - i)); 16 | Thread.sleep(1000); 17 | } 18 | 19 | for (int i = 0; i < 1500; i++) { 20 | robot.keyPress(KeyEvent.VK_E); 21 | robot.keyRelease(KeyEvent.VK_E); 22 | 23 | robot.mousePress(InputEvent.BUTTON1_DOWN_MASK); 24 | robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK); 25 | 26 | robot.keyPress(KeyEvent.VK_E); 27 | robot.keyRelease(KeyEvent.VK_E); 28 | 29 | System.out.println("Iteration: " + i); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/stream/StreamFilterMapCollect.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.stream; 2 | 3 | import java.util.ArrayList; 4 | import java.util.stream.Collectors; 5 | 6 | public class StreamFilterMapCollect { 7 | 8 | public static void main(String[] args) { 9 | new ArrayList().stream() 10 | .filter(i -> i % 2 == 0) 11 | .map(Math::sqrt) 12 | .collect(Collectors.toList()); 13 | 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/theplanetcrafter/FileToByteArrayText.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.theplanetcrafter; 2 | 3 | import java.nio.file.*; 4 | 5 | public class FileToByteArrayText { 6 | 7 | public static void main(String[] args) throws Throwable { 8 | 9 | var data = Files.readAllBytes(Paths.get("c:\\Users\\akarnokd\\Downloads\\back_circle_arrow.png")); 10 | 11 | int j = 0; 12 | for (var i : data) { 13 | System.out.printf("0x%02X", i); 14 | System.out.print(", "); 15 | 16 | if (++j == 16) { 17 | j = 0; 18 | System.out.println(); 19 | } 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/theplanetcrafter/GridMap.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.theplanetcrafter; 2 | 3 | import java.awt.*; 4 | import java.awt.image.BufferedImage; 5 | import java.io.File; 6 | 7 | import javax.imageio.ImageIO; 8 | 9 | public class GridMap { 10 | 11 | public static void main(String[] args) throws Throwable { 12 | BufferedImage bimg = new BufferedImage(1000, 1000, BufferedImage.TYPE_INT_ARGB); 13 | Graphics2D g2 = bimg.createGraphics(); 14 | 15 | g2.setColor(Color.black); 16 | g2.setStroke(new BasicStroke(4)); 17 | 18 | g2.drawLine(0, 600, 1000, 600); 19 | g2.drawLine(400, 0, 400, 1000); 20 | 21 | g2.setStroke(new BasicStroke(1)); 22 | 23 | for (int x = 0; x < 1000; x += 50) { 24 | g2.drawLine(0, x, 1000, x); 25 | g2.drawLine(x, 0, x, 1000); 26 | } 27 | 28 | ImageIO.write(bimg, "png", new File("c:\\users\\akarnokd\\downloads\\map_grid.png")); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/theplanetcrafter/InventoryPrintLn.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.theplanetcrafter; 2 | 3 | public class InventoryPrintLn { 4 | public static void main(String[] args) { 5 | for (int i = 3036; i < 3200; i++) { 6 | System.out.printf("{\"id\":%s,\"woIds\":\"\",\"size\": 80,\"demandGrps\":\"\",\"supplyGrps\":\"\",\"priority\":0}|%n", i); 7 | } 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/main/java/hu/akarnokd/theplanetcrafter/SaveDisplayNameFixer.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.theplanetcrafter; 2 | 3 | import java.nio.file.*; 4 | 5 | public class SaveDisplayNameFixer { 6 | 7 | public static void main(String[] args) throws Throwable { 8 | var p = Paths.get("c:\\Users\\akarnokd\\Downloads\\Standard.json"); 9 | var p2 = Paths.get("c:\\Users\\akarnokd\\Downloads\\Standard_fixed.json"); 10 | var lines = Files.readAllLines(p); 11 | 12 | for (int i = 0; i < lines.size(); i++) { 13 | var s = lines.get(i); 14 | if (s.contains("saveDisplayName")) { 15 | s = s.replace("\\\\", ""); 16 | lines.set(i, s); 17 | } 18 | } 19 | Files.write(p2, lines); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/asyncenum/StageCancel.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.asyncenum; 2 | 3 | import java.util.concurrent.CompletableFuture; 4 | 5 | public final class StageCancel { 6 | private StageCancel() { } 7 | public static void main(String[] args) throws Exception { 8 | CompletableFuture f = CompletableFuture.supplyAsync(() -> { 9 | try { 10 | Thread.sleep(1000); 11 | } catch (Exception e) { 12 | e.printStackTrace(); 13 | } 14 | return 1; 15 | }); 16 | 17 | CompletableFuture g = f.whenComplete((v, e) -> { System.out.println(v); }); 18 | 19 | g.cancel(true); 20 | 21 | System.out.println("+" + f.get()); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/iterables/IxNulls.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.iterables; 2 | 3 | import java.util.Arrays; 4 | 5 | import org.junit.Test; 6 | 7 | import ix.Ix; 8 | 9 | public class IxNulls { 10 | 11 | @Test 12 | public void test() { 13 | Ix.from(Arrays.asList("1", null, "2", "3", null)) 14 | .filter(v -> v != null) 15 | .subscribe(System.out::println); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/iterables/SingletonIteratorTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.iterables; 2 | 3 | import static org.junit.Assert.*; 4 | 5 | import java.util.*; 6 | 7 | import org.junit.Test; 8 | 9 | public class SingletonIteratorTest { 10 | 11 | @Test 12 | public void contract() { 13 | Iterator it = SingletonIterator.of(1); 14 | 15 | assertTrue(it.hasNext()); 16 | 17 | assertEquals((Integer)1, it.next()); 18 | 19 | assertFalse(it.hasNext()); 20 | 21 | try { 22 | it.next(); 23 | fail("Should have thrown"); 24 | } catch (NoSuchElementException ex) { 25 | // expected 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/reactive/SubmissionPublisherTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactive; 2 | 3 | import java.util.concurrent.SubmissionPublisher; 4 | 5 | import org.junit.Test; 6 | 7 | public class SubmissionPublisherTest { 8 | 9 | @Test 10 | public void test() { 11 | SubmissionPublisher sp = new SubmissionPublisher<>(); 12 | sp.submit(1); 13 | sp.submit(2); 14 | sp.close(); 15 | 16 | sp.consume(System.out::println).join(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/reactive/observable/IObservableTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactive.observable; 2 | 3 | import org.junit.*; 4 | 5 | import hu.akarnokd.reactive.observables.IObservable; 6 | 7 | public class IObservableTest { 8 | 9 | @Test 10 | public void just() { 11 | Assert.assertEquals((Integer)1, IObservable.just(1).first()); 12 | } 13 | 14 | @Test 15 | public void characters() { 16 | Assert.assertEquals((Integer)(int)'d', IObservable.characters("abcd").last()); 17 | } 18 | 19 | @Test 20 | public void concatArray() { 21 | Assert.assertEquals("d", IObservable.concatArray(IObservable.just("a"), IObservable.just("d")).last()); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/reactor/BufferUntilTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactor; 2 | 3 | import java.time.Duration; 4 | 5 | import org.junit.Test; 6 | 7 | import reactor.core.publisher.*; 8 | 9 | public class BufferUntilTest { 10 | 11 | @Test 12 | public void test() { 13 | Hooks.onOperatorDebug(); 14 | 15 | Flux.range(0, 1000) 16 | .bufferUntil(v -> true) 17 | .flatMap(v -> Mono.delay(Duration.ofMillis(10))) 18 | .blockLast(); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/reactor/DelayedBuffer.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactor; 2 | 3 | import java.time.Duration; 4 | import java.util.List; 5 | 6 | import reactor.core.publisher.*; 7 | 8 | public final class DelayedBuffer { 9 | 10 | private DelayedBuffer() { } 11 | 12 | public static void main(String[] args) { 13 | Flux.just(1, 2, 3, 6, 7, 10) 14 | .flatMap(v -> Mono.delay(Duration.ofMillis(v * 1000)).doOnNext(w -> System.out.println("T=" + v)).map(w -> v)) 15 | .transform(f -> delayedBufferAfterFirst(f, Duration.ofSeconds(2))) 16 | .doOnNext(System.out::println) 17 | .blockLast(); 18 | } 19 | 20 | public static Flux> delayedBufferAfterFirst(Flux source, Duration d) { 21 | return source 22 | .publish(f -> { 23 | return f.take(1).collectList() 24 | .concatWith(f.buffer(d).take(1)) 25 | .repeatWhen(r -> r.takeUntilOther(f.ignoreElements())); 26 | }); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/reactor/DoOnSubscribeTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactor; 2 | 3 | import java.util.*; 4 | 5 | import org.junit.Test; 6 | 7 | import reactor.core.publisher.Mono; 8 | import reactor.core.scheduler.Schedulers; 9 | 10 | public class DoOnSubscribeTest { 11 | 12 | @Test 13 | public void test() { 14 | Set set = new HashSet<>(); 15 | for (int i = 0; i < 100000; i++) { 16 | Mono source = Mono.just(1).doOnSubscribe(s -> set.add(Thread.currentThread().getName())); 17 | 18 | Mono.just(1) 19 | .publishOn(Schedulers.single()) 20 | .flatMap(v -> source) 21 | .ignoreElement() 22 | .block(); 23 | } 24 | 25 | System.out.println(set); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/reactor/FilterWhenTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactor; 2 | 3 | import org.junit.*; 4 | 5 | import reactor.core.publisher.*; 6 | 7 | public class FilterWhenTest { 8 | 9 | @Test 10 | public void filterAllOut() { 11 | int[] count = { 0, 0 }; 12 | Flux.range(1, 1000) 13 | .doOnNext(v -> count[0]++) 14 | .doOnRequest(System.out::println) 15 | .filterWhen(o1 -> Mono.just(false)) //REMOVE 16 | .flatMap(s -> Flux.just(new Object()).hide()) //REMOVE 17 | .subscribe(); 18 | 19 | Assert.assertEquals(1000, count[0]); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/reactor/FlatMapMonoVoid.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactor; 2 | 3 | import org.junit.*; 4 | 5 | import reactor.core.publisher.*; 6 | 7 | public class FlatMapMonoVoid { 8 | 9 | @Test 10 | public void test() { 11 | int c[] = { 0 }; 12 | Flux.range(1, 1000) 13 | .flatMap(v -> Mono.fromRunnable(() -> { c[0]++; })) 14 | .ignoreElements() 15 | .block(); 16 | 17 | Assert.assertEquals(1000, c[0]); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/reactor/GroupParallel.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactor; 2 | 3 | import java.util.concurrent.atomic.AtomicInteger; 4 | 5 | import org.junit.Test; 6 | 7 | import reactor.core.publisher.Flux; 8 | import reactor.core.scheduler.Schedulers; 9 | 10 | public class GroupParallel { 11 | 12 | @Test 13 | public void parallelGroupComputation() throws Exception { 14 | 15 | AtomicInteger wip = new AtomicInteger(); 16 | 17 | Flux.range(1, 1000_000) 18 | .groupBy(i -> i % 8) 19 | .flatMap(g -> g) 20 | .parallel() 21 | .runOn(Schedulers.parallel()) 22 | .sequential() 23 | .subscribe(c -> { 24 | 25 | if (wip.getAndIncrement() != 0) { 26 | System.err.println("Concurrent invocation!"); 27 | } 28 | try { 29 | Thread.sleep(1); 30 | } catch (Throwable ex) { 31 | ex.printStackTrace(); 32 | } 33 | 34 | wip.decrementAndGet(); 35 | }); 36 | 37 | Thread.sleep(100000); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/reactor/Reactor2Test.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactor; 2 | import java.util.Collections; 3 | 4 | import reactor.core.publisher.Flux; 5 | 6 | public final class Reactor2Test { 7 | private Reactor2Test() { } 8 | 9 | public static void main(String... args) { 10 | Flux source = Flux.create((e) -> { 11 | for (int i = 0; i < 300; i++) { 12 | e.next(i); 13 | } 14 | e.complete(); 15 | }); 16 | Flux cached = source.cache(); 17 | 18 | long sourceCount = source.concatMapIterable(Collections::singleton) 19 | .distinct().count().block(); 20 | long cachedCount = cached.concatMapIterable(Collections::singleton) 21 | .distinct().count().block(); 22 | 23 | System.out.println("source: " + sourceCount); 24 | System.out.println("cached: " + cachedCount); 25 | } 26 | } -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/reactor/StreamRemainingTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactor; 2 | 3 | import java.util.stream.*; 4 | 5 | import org.junit.Test; 6 | 7 | public class StreamRemainingTest { 8 | 9 | @Test 10 | public void test() { 11 | Stream source = IntStream.range(1, 11).boxed(); 12 | 13 | Stream result = source.onClose(() -> { 14 | source.iterator().forEachRemaining(System.out::println); 15 | }); 16 | 17 | try (Stream stream = result.limit(5)) { 18 | stream.forEach(v -> System.out.println("Consumed: " + v)); 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/reactor/TestLazy.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.reactor; 2 | import reactor.core.publisher.Flux; 3 | 4 | public class TestLazy { 5 | public static void main(String[] args) { 6 | Flux.just(1, 2, 3) 7 | .filter(s -> s > 4) 8 | .zipWith(Flux.defer(() -> Flux.just(get1(), get2(), get3())), (a, b) -> a + b) 9 | .subscribe(System.out::println); 10 | 11 | Flux.just(1, 2, 3) 12 | .filter(s -> s > 4) 13 | .flatMap(a -> Flux.defer(() -> Flux.just(fromFlatMap()))) 14 | .subscribe(System.out::println); 15 | } 16 | 17 | private static int fromFlatMap() { 18 | System.out.println("from flatMap"); 19 | return 0; 20 | } 21 | 22 | private static int get1() { 23 | System.out.println("get 1"); 24 | return 1; 25 | } 26 | 27 | private static int get2() { 28 | System.out.println("get 2"); 29 | return 2; 30 | } 31 | 32 | private static int get3() { 33 | System.out.println("get 3"); 34 | return 3; 35 | } 36 | } -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/retrofit2/ResponseBodyNull.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.retrofit2; 2 | 3 | import java.lang.reflect.Constructor; 4 | 5 | import org.junit.*; 6 | 7 | import io.reactivex.Observable; 8 | import retrofit2.Response; 9 | 10 | public class ResponseBodyNull { 11 | 12 | @Test 13 | public void responseBodyNull() throws Exception { 14 | 15 | Response response = Response.success(null); 16 | 17 | Assert.assertNull(response.body()); 18 | 19 | Class clazz = Class.forName("retrofit2.adapter.rxjava2.BodyObservable"); 20 | Constructor c = clazz.getDeclaredConstructor(Observable.class); 21 | c.setAccessible(true); 22 | @SuppressWarnings({ "unchecked", "rawtypes" }) 23 | Observable o = (Observable)c.newInstance(Observable.just(response)); 24 | o.test() 25 | .assertNever(r -> r == null) 26 | .assertTerminated(); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/AmbTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import org.junit.Test; 4 | 5 | import rx.Observable; 6 | 7 | public class AmbTest { 8 | 9 | @Test 10 | public void test() throws Exception { 11 | Observable obs1 = Observable 12 | .just("obs 1 event") 13 | .doOnSubscribe(() -> System.out.println("obs1 sub")) 14 | .doOnUnsubscribe(() -> System.out.println("obs1 unsub")); 15 | 16 | Observable obs2 = Observable 17 | .just("obs 2 event") 18 | .doOnSubscribe(() -> System.out.println("obs2 sub")) 19 | .doOnUnsubscribe(() -> System.out.println("obs2 unsub")); 20 | 21 | Observable 22 | .amb(obs1, obs2) 23 | .subscribe(System.out::println); 24 | 25 | Thread.sleep(500); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/CompleteDos.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import org.junit.Test; 4 | 5 | import rx.Completable; 6 | import rx.schedulers.Schedulers; 7 | 8 | public class CompleteDos { 9 | 10 | @Test 11 | public void test() throws Exception { 12 | Completable.fromAction(() -> System.out.println("A1")) 13 | .doOnSubscribe(s -> 14 | System.out.println("---> A1 doOnSubscribe") 15 | ) 16 | .doOnCompleted(() -> System.out.println("---> A1 doOnCompleted")) 17 | .doOnUnsubscribe(() -> 18 | System.out.println("---> A1 doOnUnsubscribe") 19 | ) 20 | .andThen( 21 | Completable.fromAction(() -> System.out.println("B1"))) 22 | .doOnSubscribe(s -> 23 | System.out.println("---> B1 doOnSubscribe") 24 | ) 25 | .doOnCompleted(() -> System.out.println("---> B1 doOnCompleted")) 26 | .doOnUnsubscribe(() -> 27 | System.out.println("---> B1 doOnUnsubscribe") 28 | ) 29 | .subscribeOn(Schedulers.io()) 30 | .observeOn(Schedulers.computation()) 31 | .subscribe(); 32 | 33 | Thread.sleep(10000); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/ConcatReplayTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import org.junit.Test; 4 | 5 | import rx.*; 6 | 7 | public class ConcatReplayTest { 8 | 9 | @Test 10 | public void test() { 11 | Observable obs1 = Observable.create(emitter -> { 12 | emitter.onNext(1); 13 | emitter.onCompleted(); 14 | }, Emitter.BackpressureMode.BUFFER); 15 | 16 | Observable obs2 = Observable.create(emitter -> { 17 | emitter.onNext(2); 18 | emitter.onCompleted(); 19 | }, Emitter.BackpressureMode.BUFFER); 20 | 21 | Observable both = Observable 22 | .concatDelayError(obs1, obs2) 23 | .replay().autoConnect(); 24 | 25 | both.test().assertResult(1, 2); 26 | 27 | both.test().assertResult(1, 2); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/FirstAndThrowTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import org.junit.Test; 4 | 5 | import rx.Observable; 6 | import rx.plugins.RxJavaHooks; 7 | 8 | public class FirstAndThrowTest { 9 | 10 | @Test 11 | public void test() { 12 | RxJavaHooks.setOnError(error -> System.out.println("got global error " + error)); 13 | Observable.just("1") 14 | .first() 15 | .toSingle() 16 | .subscribe( 17 | it -> { 18 | System.out.println("going to throw"); 19 | throw new NullPointerException("bla"); 20 | }, 21 | error -> System.out.println("got error " + error) 22 | ); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/GroupByTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import rx.Observable; 4 | 5 | public final class GroupByTest { 6 | private GroupByTest() { } 7 | 8 | public static void main(String[] args) { 9 | Observable names = Observable.just( 10 | "John", "Steve", "Ruth", 11 | "Sam", "Jane", "James"); 12 | 13 | names.groupBy(s -> s.charAt(0)) 14 | .flatMap(grp -> grp.publish(o -> o.first().concatWith(o.ignoreElements()))) 15 | .subscribe(s -> System.out.println(s)); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/InferenceSO.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | public class InferenceSO { 4 | 5 | // Observable whenExceptionIs(Class what, Func1> result) { 6 | // return t -> { 7 | // return what.isInstance(t) ? result.call(t) : Observable.error(t); 8 | // }; 9 | // } 10 | } 11 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/InteropCheck.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import org.junit.Test; 4 | 5 | import hu.akarnokd.rxjava.interop.RxJavaInterop; 6 | 7 | public class InteropCheck { 8 | 9 | @Test 10 | public void test() { 11 | rx.subjects.PublishSubject sj = rx.subjects.PublishSubject.create(); 12 | io.reactivex.subjects.Subject sj2 = RxJavaInterop.toV2Subject(sj); 13 | sj2.test(); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/InterruptFlow.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import java.util.concurrent.CountDownLatch; 4 | 5 | import org.junit.Test; 6 | 7 | import rx.Completable; 8 | import rx.schedulers.Schedulers; 9 | 10 | public class InterruptFlow { 11 | @Test 12 | public void testInterrupt() throws InterruptedException { 13 | final int count = 1000; 14 | CountDownLatch latch = new CountDownLatch(count); 15 | 16 | for (int i = 0; i < count; i++) { 17 | Completable.complete() 18 | .subscribeOn(Schedulers.io()) 19 | .observeOn(Schedulers.io()) // The problem does not occur if you comment out this line 20 | .andThen(Completable.fromAction(() -> { 21 | try { 22 | Thread.sleep(3000); 23 | } catch (InterruptedException e) { 24 | System.out.println("Interrupted!"); // This is output periodically 25 | } 26 | })) 27 | .subscribe(() -> latch.countDown()); 28 | } 29 | 30 | latch.await(); 31 | //testInterrupt(); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/ListFlatMappingTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import java.util.List; 4 | 5 | import org.junit.Test; 6 | 7 | import rx.*; 8 | import rx.schedulers.Schedulers; 9 | 10 | public class ListFlatMappingTest { 11 | 12 | Single> getList() { 13 | return null; 14 | } 15 | 16 | Observable getSubdetails(Integer item) { 17 | return null; 18 | } 19 | 20 | @Test 21 | public void test() { 22 | getList() 23 | .subscribeOn(Schedulers.io()) 24 | .flatMapObservable(list -> Observable.from(list)) 25 | .flatMap(each -> getSubdetails(each)) 26 | .subscribe(new Subscriber() { 27 | @Override 28 | public void onNext(Boolean t) { 29 | } 30 | @Override 31 | public void onError(Throwable error) { 32 | } 33 | @Override 34 | public void onCompleted() { 35 | } 36 | }); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/ObserveOnTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import rx.Observable; 8 | import rx.observers.TestSubscriber; 9 | import rx.schedulers.*; 10 | 11 | public class ObserveOnTest { 12 | @Test 13 | public void completeExactRequest() { 14 | TestSubscriber ts = TestSubscriber.create(0); 15 | 16 | TestScheduler test = Schedulers.test(); 17 | 18 | Observable.range(1, 10).observeOn(test).subscribe(ts); 19 | 20 | test.advanceTimeBy(1, TimeUnit.SECONDS); 21 | 22 | ts.assertNoValues(); 23 | ts.assertNoErrors(); 24 | ts.assertNotCompleted(); 25 | 26 | ts.requestMore(10); 27 | 28 | test.advanceTimeBy(1, TimeUnit.SECONDS); 29 | 30 | ts.assertValueCount(10); 31 | ts.assertNoErrors(); 32 | ts.assertCompleted(); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/PublishBufferZip.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import org.junit.Test; 4 | 5 | import rx.subjects.PublishSubject; 6 | 7 | public class PublishBufferZip { 8 | 9 | @Test 10 | public void normal() { 11 | PublishSubject boundary = PublishSubject.create(); 12 | 13 | PublishSubject source = PublishSubject.create(); 14 | 15 | boundary.publish(b -> source.buffer(b).zipWith(b, (list, e) -> { list.add(e); return list; })) 16 | .subscribe(System.out::println); 17 | 18 | source.onNext(1); 19 | source.onNext(2); 20 | source.onNext(3); 21 | 22 | boundary.onNext(100); 23 | 24 | source.onNext(4); 25 | source.onNext(5); 26 | 27 | boundary.onNext(200); 28 | 29 | source.onNext(6); 30 | boundary.onNext(300); 31 | 32 | boundary.onNext(400); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/PublishExample.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import rx.Observable; 4 | 5 | public final class PublishExample { 6 | 7 | private PublishExample() { } 8 | 9 | public static void main(String[] args) { 10 | Observable.range(1, 10) 11 | .doOnSubscribe(() -> System.out.println("Subscribed")) 12 | .publish(o -> Observable.zip(o.map(v -> v * 10), o.map(v -> v * 20), (a, b) -> a + "-" + b)) 13 | .subscribe(System.out::println, Throwable::printStackTrace); 14 | 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/RecurseWithDefer.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import org.junit.Test; 4 | 5 | import rx.Observable; 6 | 7 | public class RecurseWithDefer { 8 | 9 | Observable numbers(int start) { 10 | return Observable.just(start) 11 | .concatWith(Observable.defer(() -> numbers(start + 1))); 12 | } 13 | @Test 14 | public void test() { 15 | numbers(1) 16 | .take(1000) 17 | .subscribe(System.out::println, Throwable::printStackTrace); 18 | } 19 | 20 | io.reactivex.Observable numbers2(int start) { 21 | return io.reactivex.Observable.just(start) 22 | .concatWith(io.reactivex.Observable.defer(() -> numbers2(start + 1))); 23 | } 24 | @Test 25 | public void test2() { 26 | numbers2(1) 27 | .take(1000) 28 | .subscribe(System.out::println, Throwable::printStackTrace); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/Replay1RetentionTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.disposables.Disposable; 6 | import rx.*; 7 | import rx.subjects.PublishSubject; 8 | 9 | public class Replay1RetentionTest { 10 | 11 | @Test 12 | public void test() { 13 | 14 | PublishSubject ps = PublishSubject.create(); 15 | 16 | Observable o = ps.replay(1).refCount(); 17 | Subscription s = o.subscribe(System.out::println); 18 | 19 | ps.onNext(1); 20 | 21 | ps.onNext(2); 22 | 23 | ps.onNext(3); 24 | 25 | System.out.println(s); 26 | 27 | o.subscribe(System.out::println); 28 | } 29 | 30 | @Test 31 | public void test2() { 32 | 33 | io.reactivex.subjects.PublishSubject ps = io.reactivex.subjects.PublishSubject.create(); 34 | 35 | io.reactivex.Observable o = ps.replay(1).refCount(); 36 | Disposable s = o.subscribe(System.out::println); 37 | 38 | ps.onNext(1); 39 | 40 | ps.onNext(2); 41 | 42 | ps.onNext(3); 43 | 44 | System.out.println(s); 45 | 46 | o.subscribe(System.out::println); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/SingleUnsubscribe.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import org.junit.Test; 4 | 5 | import rx.Single; 6 | import rx.schedulers.Schedulers; 7 | 8 | public class SingleUnsubscribe { 9 | @Test 10 | public void test() throws Exception { 11 | Single.fromCallable(() -> 42) 12 | .subscribeOn(Schedulers.io()) 13 | .observeOn(Schedulers.computation()) 14 | .doOnSubscribe(() -> System.out.println("subscribed")) 15 | .doOnUnsubscribe(() -> System.out.println("unsubscribed")) 16 | .subscribe(integer -> System.out.println("got result")); 17 | 18 | Thread.sleep(1000); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/SingleUntil.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import java.util.concurrent.CancellationException; 4 | 5 | import org.junit.Test; 6 | 7 | import rx.Single; 8 | import rx.observers.TestSubscriber; 9 | import rx.subjects.PublishSubject; 10 | 11 | public class SingleUntil { 12 | @Test 13 | public void singleTakeUntil() { 14 | PublishSubject controller = PublishSubject.create(); 15 | 16 | TestSubscriber testSubscriber = new TestSubscriber<>(0); 17 | 18 | Single.just("Hello") 19 | .toObservable() 20 | .takeUntil(controller.map(v -> { throw new CancellationException(); })) 21 | .subscribe(testSubscriber); 22 | 23 | controller.onNext("Stop flow"); 24 | 25 | testSubscriber.requestMore(1); 26 | testSubscriber.assertNoValues(); 27 | testSubscriber.assertError(CancellationException.class); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/Ternary.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import rx.Observable; 4 | import rx.functions.Func1; 5 | 6 | public final class Ternary { 7 | private Ternary() { } 8 | 9 | public static void main(String[] args) { 10 | Func1> func = s -> s.contains("1") ? Observable.just(s) : Observable.empty(); 11 | Observable.just("A1", "A2") 12 | .flatMap( s -> (s.contains("1")) ? Observable.just(s) : Observable.empty() )// <--------- this approach did not work 13 | .flatMap( s -> { return (s.contains("1")) ? Observable.just(s) : Observable.empty(); } )// <--------- this approach did not work 14 | .flatMap(func) // <---- this worked 15 | .subscribe(s -> { System.out.println(s); }); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/ZipRandomTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import rx.Observable; 8 | 9 | public class ZipRandomTest { 10 | 11 | static long randomTime() { 12 | return 2; 13 | } 14 | 15 | @Test 16 | public void test() throws Exception { 17 | Observable delay = Observable.just("") 18 | .switchMap(dummy -> Observable.timer(randomTime(), TimeUnit.SECONDS)) 19 | .map( a -> String.valueOf(a) ) 20 | .repeat(); 21 | 22 | Observable messages = Observable.just("Test") //eventually lines from a file... 23 | .repeat(); 24 | 25 | messages.zipWith(delay, (d, msg) -> ""+d+" "+msg ).subscribe( System.out::println ); 26 | 27 | Thread.sleep(10000); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava/strings/LinesBackpressure.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava.strings; 2 | 3 | import java.nio.charset.StandardCharsets; 4 | import java.util.Arrays; 5 | 6 | import org.junit.Test; 7 | 8 | import rx.Observable; 9 | import rx.observables.StringObservable; 10 | import rx.schedulers.Schedulers; 11 | 12 | public class LinesBackpressure { 13 | 14 | @Test 15 | public void decode() { 16 | byte[] bytes = new byte[16]; 17 | Arrays.fill(bytes, (byte)65); 18 | 19 | byte[] bytes2 = new byte[16]; 20 | Arrays.fill(bytes, (byte)65); 21 | bytes[15] = 10; 22 | 23 | Observable data = Observable.just(bytes, bytes, bytes2).repeat(500); 24 | 25 | StringObservable.decode(data, StandardCharsets.UTF_8) 26 | .observeOn(Schedulers.computation(), false, 1) 27 | .toBlocking() 28 | .subscribe(System.out::println); 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/Amb2Test.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Observable; 6 | 7 | public class Amb2Test { 8 | @Test 9 | @SuppressWarnings("unchecked") 10 | public void test() throws Exception { 11 | Observable obs1 = Observable 12 | .just("obs 1 event") 13 | .doOnSubscribe(s -> System.out.println("obs1 sub")) 14 | .doOnDispose(() -> System.out.println("obs1 unsub")); 15 | 16 | Observable obs2 = Observable 17 | .just("obs 2 event") 18 | .doOnSubscribe(s -> System.out.println("obs2 sub")) 19 | .doOnDispose(() -> System.out.println("obs2 unsub")); 20 | 21 | Observable 22 | .ambArray(obs1, obs2) 23 | .subscribe(System.out::println); 24 | 25 | Thread.sleep(500); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/AssemblyHooksExample.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Observable; 6 | import io.reactivex.internal.operators.observable.ObservableFromArray; 7 | import io.reactivex.plugins.RxJavaPlugins; 8 | 9 | public class AssemblyHooksExample { 10 | 11 | @Test 12 | public void test() { 13 | RxJavaPlugins.setOnObservableAssembly(o -> { 14 | if (o instanceof ObservableFromArray) { 15 | return new ObservableFromArray<>(new Integer[] { 4, 5, 6 }); 16 | } 17 | return o; 18 | }); 19 | 20 | Observable.just(1, 2, 3) 21 | .filter(v -> v > 3) 22 | .test() 23 | .assertResult(4, 5, 6); 24 | 25 | RxJavaPlugins.setOnObservableAssembly(null); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/BasicSingleCreateTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.*; 6 | import io.reactivex.functions.Consumer; 7 | 8 | public class BasicSingleCreateTest { 9 | 10 | @Test 11 | public void test() { 12 | Single.create(new SingleOnSubscribe() { 13 | @Override 14 | public void subscribe(SingleEmitter e) throws Exception { 15 | e.onSuccess("something"); 16 | } 17 | }) 18 | .subscribe(new Consumer() { 19 | @Override 20 | public void accept(String o) throws Exception { 21 | System.out.print(o); 22 | } 23 | }); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/BehaviorMulticast.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Observable; 6 | import io.reactivex.disposables.Disposable; 7 | import io.reactivex.subjects.*; 8 | 9 | public class BehaviorMulticast { 10 | 11 | @Test 12 | public void test() { 13 | Subject subject = PublishSubject.create(); 14 | Observable observable = subject.scan("zero", (a, b) -> a + ", " + b); 15 | Subject multicast = BehaviorSubject.create(); 16 | 17 | observable.subscribe(multicast); 18 | 19 | Disposable first = multicast.subscribe(System.out::println); // "zero" 20 | subject.onNext("one"); // "zero, one" 21 | first.dispose(); 22 | Disposable second = multicast.subscribe(System.out::println); // "zero, one" 23 | subject.onNext("two"); // "zero, one, two" 24 | second.dispose(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/BehaviorSubjectCombineLatest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Observable; 6 | import io.reactivex.subjects.BehaviorSubject; 7 | 8 | public class BehaviorSubjectCombineLatest { 9 | 10 | BehaviorSubject subject1; 11 | BehaviorSubject subject2; 12 | 13 | @Test 14 | public void test() throws Exception { 15 | subject1 = BehaviorSubject.createDefault("hello"); 16 | subject2 = BehaviorSubject.createDefault("goodbye"); 17 | 18 | subject1.subscribe(v -> System.out.println("Subject1 it1: " + v)); 19 | 20 | click(); 21 | 22 | Thread.sleep(1); 23 | 24 | click(); 25 | 26 | Thread.sleep(1); 27 | 28 | click(); 29 | } 30 | 31 | void click() { 32 | subject1.onNext("hello button clicked " + System.currentTimeMillis()); 33 | 34 | Observable.combineLatest(subject1, subject2, (a, b) -> "biFun call " + a + ", " + b) 35 | .subscribe(v -> System.out.println("Combined latest: " + v)); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/BlockingSingleTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Observable; 6 | import io.reactivex.schedulers.Schedulers; 7 | 8 | public class BlockingSingleTest { 9 | 10 | @Test 11 | public void test() { 12 | Observable source1 = Observable.fromCallable(() -> { 13 | throw new InterruptedException(); 14 | }).subscribeOn(Schedulers.io()); 15 | Observable source2 = Observable.fromCallable(() -> "second_observable") 16 | .subscribeOn(Schedulers.io()); 17 | Observable.zip(source1, source2, (o, s) -> "result").blockingSingle(); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/BlockingSubscribeOrdering.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Flowable; 6 | 7 | public class BlockingSubscribeOrdering { 8 | 9 | @Test 10 | public void test() { 11 | Flowable.just(1, 2) 12 | .concatWith(Flowable.error(new Exception("whoops"))) 13 | .blockingSubscribe(v -> System.out.println("received: " + v), 14 | e -> { 15 | e.printStackTrace(System.out); 16 | }, () -> System.out.println("completed")); 17 | 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/BufferDelayErrorTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.List; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.*; 8 | import io.reactivex.processors.PublishProcessor; 9 | 10 | public class BufferDelayErrorTest { 11 | 12 | 13 | @Test 14 | public void test() { 15 | Flowable.range(0, 10) 16 | .doOnNext(x -> { 17 | if(x == 7) { 18 | throw new RuntimeException(); 19 | } 20 | }) 21 | .compose(bufferDelayError(5)) 22 | .subscribe(System.out::println, System.out::println); 23 | } 24 | 25 | static FlowableTransformer> bufferDelayError(int size) { 26 | return o -> Flowable.defer(() -> { 27 | PublishProcessor> ps = PublishProcessor.create(); 28 | 29 | return o 30 | .doOnComplete(() -> ps.onComplete()) 31 | .onErrorResumeNext(e -> { 32 | ps.onError(e); 33 | return Flowable.empty(); 34 | }) 35 | .buffer(size) 36 | .concatWith(ps); 37 | }); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/BufferExactDisposeTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Flowable; 8 | 9 | public class BufferExactDisposeTest { 10 | 11 | @Test 12 | public void test() { 13 | Flowable.range(1, 5) 14 | .doOnCancel(() -> new Exception().printStackTrace()) 15 | .takeUntil(v -> v == 4) 16 | .buffer(5, TimeUnit.SECONDS) 17 | .blockingLast(); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/CombineLatestError.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.Arrays; 4 | import java.util.concurrent.TimeUnit; 5 | 6 | import org.junit.*; 7 | 8 | import io.reactivex.Observable; 9 | 10 | public class CombineLatestError { 11 | 12 | @Test 13 | public void test() { 14 | final int result = Observable.combineLatestDelayError( 15 | Arrays.asList( 16 | Observable.just(41).concatWith(Observable.error(new Exception("Failure"))), 17 | Observable.just(1).delay(1, TimeUnit.SECONDS) 18 | ), 19 | ints -> { 20 | System.out.println(Arrays.toString(ints)); 21 | return ((int) ints[0]) + ((int) ints[1]); 22 | } 23 | ).blockingFirst(); 24 | 25 | Assert.assertEquals(42, result); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ConcatAnomalyTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.*; 6 | import io.reactivex.schedulers.Schedulers; 7 | 8 | public class ConcatAnomalyTest { 9 | 10 | @Test 11 | public void test() throws Exception { 12 | Flowable.concat( 13 | Flowable.just(1, 2) 14 | .concatMap(v -> Flowable.just(3, 4)) 15 | .subscribeOn(Schedulers.single()) 16 | .observeOn(Schedulers.io()) 17 | .doOnNext(v -> System.out.println("[1]: " + v)), 18 | Single 19 | .just("yup") 20 | .subscribeOn(Schedulers.single()) 21 | .doOnSuccess(o -> System.out.println("[2] called: " + o)) 22 | .toFlowable() 23 | ) 24 | .observeOn(Schedulers.computation()) 25 | .subscribe(v -> System.out.println("[3]: " + v), Throwable::printStackTrace, () -> System.out.println("Done")); 26 | 27 | Thread.sleep(1000); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ConcatEagerDebounceTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.io.IOException; 4 | import java.util.concurrent.TimeUnit; 5 | 6 | import org.junit.Test; 7 | 8 | import io.reactivex.Observable; 9 | import io.reactivex.functions.Function; 10 | 11 | public class ConcatEagerDebounceTest { 12 | 13 | @Test 14 | @SuppressWarnings("unchecked") 15 | public void test() { 16 | Observable.concatArrayEagerDelayError( 17 | Observable.just(1).delay(100, TimeUnit.MILLISECONDS), 18 | Observable.error(new IOException()).delay(200, TimeUnit.MILLISECONDS, true) 19 | ) 20 | .onErrorResumeNext((Function>)(error -> Observable.error(error).delay(500, TimeUnit.MILLISECONDS, true))) 21 | .doOnEach(System.out::println) 22 | .debounce(400, TimeUnit.MILLISECONDS) 23 | .blockingSubscribe( 24 | System.out::println, 25 | Throwable::printStackTrace 26 | ); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ConcatMapDelayTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.*; 6 | 7 | public class ConcatMapDelayTest { 8 | @Test 9 | public void publisherOfPublisherDelayErrorX() { 10 | 11 | Flowable.concatDelayError( 12 | Flowable.just( 13 | Flowable.just(1, 2), 14 | Flowable.error(new Exception("test")), 15 | Flowable.just(3, 4))) 16 | .test() 17 | .assertFailure(Exception.class, 1, 2, 3, 4); 18 | } 19 | @Test 20 | public void publisherOfPublisherDelayErrorX2() { 21 | 22 | Observable.concatDelayError( 23 | Observable.just( 24 | Observable.just(1, 2), 25 | Observable.error(new Exception("test")), 26 | Observable.just(3, 4))) 27 | .test() 28 | .assertFailure(Exception.class, 1, 2, 3, 4); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/Covariance.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.*; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Single; 8 | 9 | public class Covariance { 10 | 11 | @Test 12 | public void test() { 13 | Single> list = null; 14 | 15 | //m1(list); 16 | m2(list); 17 | } 18 | 19 | public void m1(Single> p) { 20 | 21 | } 22 | 23 | 24 | public void m2(Single> p) { 25 | 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/DebounceEmpty.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.*; 6 | import io.reactivex.functions.Function; 7 | 8 | public class DebounceEmpty { 9 | @Test 10 | public void debounceOnEmpty() { 11 | Observable.empty().debounce(new Function>() { 12 | @Override 13 | public ObservableSource apply(Object o) { 14 | return Observable.just(new Object()); 15 | } 16 | }).subscribe(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/DebounceRange.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | 9 | public class DebounceRange { 10 | 11 | @Test 12 | public void test() { 13 | Observable.range(1, 10000) 14 | .debounce(1000, TimeUnit.MILLISECONDS) 15 | .blockingSubscribe(System.out::println); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/DelayBetween.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.time.LocalTime; 4 | import java.util.concurrent.TimeUnit; 5 | 6 | import org.junit.Test; 7 | 8 | import io.reactivex.*; 9 | 10 | public class DelayBetween { 11 | 12 | static Maybe getId(String id) { 13 | return Maybe.just(id); 14 | } 15 | 16 | @Test 17 | public void test() { 18 | String[] ids = {"1", "2", "3", "4", "5", "6", "7", "8"}; 19 | Flowable.fromArray(ids) // or fromIterable(ids) 20 | .zipWith( 21 | Flowable.interval(0, 5, TimeUnit.SECONDS).onBackpressureBuffer(), 22 | (id, time) -> id 23 | ) 24 | .flatMapMaybe((String id) -> getId(id), false, 1) 25 | // .repeat() 26 | .blockingSubscribe((String v) -> { 27 | System.out.print(LocalTime.now()); 28 | System.out.print(" - "); 29 | System.out.println(v); 30 | }); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/DistinctUntilChangedNumericDeltaTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Observable; 6 | 7 | public class DistinctUntilChangedNumericDeltaTest { 8 | 9 | @Test 10 | public void test() { 11 | Observable.just(10.0, 10.1, 10.15, 10.162, 11.0) 12 | .distinctUntilChanged((prev, curr) -> Math.abs(prev - curr) < 0.09) 13 | .subscribe(System.out::println); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/DoOnDisposeBug.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.atomic.AtomicBoolean; 4 | 5 | import org.junit.*; 6 | 7 | import io.reactivex.Completable; 8 | import io.reactivex.observers.TestObserver; 9 | 10 | public class DoOnDisposeBug { 11 | @Test 12 | public void test() { 13 | final AtomicBoolean atomicBoolean = new AtomicBoolean(); 14 | 15 | Assert.assertFalse(atomicBoolean.get()); 16 | 17 | TestObserver to = Completable.complete() 18 | .doOnDispose(() -> atomicBoolean.set(true)) 19 | .test() 20 | .assertResult(); 21 | 22 | to 23 | .dispose(); 24 | 25 | Assert.assertTrue(atomicBoolean.get()); // Fails 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/DoOnErrorInside.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.io.IOException; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.*; 8 | 9 | public class DoOnErrorInside { 10 | 11 | @Test 12 | public void test() { 13 | Observable.just(1) 14 | .flatMap(v -> single(v) 15 | .toObservable() 16 | .doOnError(w -> System.out.println("Error2 " + w)) 17 | ) 18 | .subscribe(v -> System.out.println(v), e -> System.out.println("Error " + e)); 19 | } 20 | 21 | Single single(Integer v) { 22 | return Single.error(new IOException()); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ErrorRemap.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.io.IOException; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | 9 | public class ErrorRemap { 10 | 11 | @Test 12 | public void test() { 13 | Observable.error(new IOException()) 14 | .onErrorResumeNext((Throwable e) -> Observable.error(new IllegalArgumentException())) 15 | .test() 16 | .assertFailure(IllegalArgumentException.class); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/FlatMapDisposeTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import static org.junit.Assert.*; 4 | 5 | import org.junit.Test; 6 | import org.reactivestreams.tck.flow.support.TestException; 7 | 8 | import io.reactivex.Observable; 9 | import io.reactivex.observers.TestObserver; 10 | import io.reactivex.subjects.PublishSubject; 11 | 12 | public class FlatMapDisposeTest { 13 | 14 | @SuppressWarnings("unchecked") 15 | @Test 16 | public void test() { 17 | PublishSubject ps1 = PublishSubject.create(); 18 | PublishSubject ps2 = PublishSubject.create(); 19 | PublishSubject ps3 = PublishSubject.create(); 20 | 21 | TestObserver to = Observable.fromArray(ps1, ps2, ps3) 22 | .flatMap(v -> v) 23 | .test(); 24 | 25 | assertTrue(ps1.hasObservers()); 26 | assertTrue(ps2.hasObservers()); 27 | assertTrue(ps3.hasObservers()); 28 | 29 | ps2.onError(new TestException()); 30 | 31 | assertFalse(ps1.hasObservers()); 32 | assertFalse(ps2.hasObservers()); 33 | assertFalse(ps3.hasObservers()); 34 | 35 | to.assertFailure(TestException.class); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/FlatMapFatal.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Observable; 6 | 7 | public class FlatMapFatal { 8 | 9 | @Test(expected = UnknownError.class) 10 | public void test() { 11 | Observable.just(1) 12 | .flatMap(v -> { 13 | throw new UnknownError(); 14 | }) 15 | .onErrorReturnItem(2) 16 | .test() 17 | .assertResult(2); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/FromCallableConcatMapTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import hu.akarnokd.rxjava2.schedulers.BlockingScheduler; 6 | import io.reactivex.Observable; 7 | import io.reactivex.schedulers.Schedulers; 8 | 9 | public class FromCallableConcatMapTest { 10 | 11 | @Test 12 | public void test() { 13 | BlockingScheduler bs = new BlockingScheduler(); 14 | bs.execute(() -> { 15 | Observable.fromCallable(() -> Thread.currentThread()) 16 | .concatMap(empty -> Observable.just(empty)) 17 | .subscribeOn(Schedulers.io()) 18 | .observeOn(bs) 19 | .doFinally(() -> bs.shutdown()) 20 | .subscribe(System.out::println); 21 | }); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/GenerateExampleTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.*; 8 | import io.reactivex.schedulers.Schedulers; 9 | 10 | public class GenerateExampleTest { 11 | 12 | @Test 13 | public void test() { 14 | Flowable., Integer>generate(() -> 0, (s, e) -> { 15 | e.onNext(Single.just(s + 2).subscribeOn(Schedulers.computation())); 16 | if (++s == 5) { 17 | e.onComplete(); 18 | } 19 | return s; 20 | }) 21 | .flatMapSingle(v -> v, false, 1) 22 | .test() 23 | .awaitDone(5, TimeUnit.SECONDS) 24 | .assertResult(2, 3, 4, 5, 6); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/GroupByFilterTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import rx.Observable; 6 | 7 | public class GroupByFilterTest { 8 | @Test 9 | public void test() { 10 | Observable.range(1, 100) 11 | .groupBy(n -> n % 3) 12 | .toMap(g -> g.getKey()) 13 | .flatMap(m -> m.get(0)) 14 | .subscribe(System.out::println); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/GroupByTake5.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Observable; 6 | 7 | public class GroupByTake5 { 8 | 9 | @Test 10 | public void test() { 11 | Observable.range(1, 50) 12 | .groupBy(v -> v / 10) 13 | .flatMap(group -> 14 | group.publish(p -> p.take(5).mergeWith(p.ignoreElements())) 15 | ) 16 | .subscribe(System.out::println); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/GroupByTaken.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | 9 | public class GroupByTaken { 10 | 11 | @Test 12 | public void test1() { 13 | Observable.interval(0, 1, TimeUnit.MILLISECONDS) 14 | .groupBy(n -> n % 2 == 0) 15 | .flatMapSingle(g -> { 16 | return g.take(10).toList(); 17 | }).take(2).blockingForEach(System.out::println); 18 | } 19 | 20 | @Test 21 | public void test2() { 22 | Observable.interval(0, 1, TimeUnit.MILLISECONDS) 23 | .take(20) 24 | .groupBy(n -> n % 2 == 0) 25 | .flatMapSingle(g -> { 26 | return g.toList(); 27 | }) 28 | .blockingForEach(System.out::println); 29 | } 30 | 31 | @Test 32 | public void test3() { 33 | Observable.intervalRange(0, 20, 0, 1, TimeUnit.MILLISECONDS) 34 | .groupBy(n -> n % 2 == 0) 35 | .flatMapSingle(g -> { 36 | return g.toList(); 37 | }) 38 | .blockingForEach(System.out::println); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/GroupByTimeout.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.subjects.PublishSubject; 8 | 9 | public class GroupByTimeout { 10 | @Test 11 | public void test() { 12 | PublishSubject ps = PublishSubject.create(); 13 | 14 | ps.groupBy(v -> v % 5).flatMap(g -> g.timeout(1, TimeUnit.HOURS)) 15 | .subscribe(System.out::println); 16 | 17 | 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/GroupSumExample.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Observable; 6 | 7 | public class GroupSumExample { 8 | 9 | @Test 10 | public void test() { 11 | Observable.range(1, 20) 12 | .groupBy(v -> v % 2 == 0) 13 | .flatMapMaybe(group -> { 14 | return group.reduce((a, b) -> a + b) 15 | .map(v -> "Group " + group.getKey() + " sum is " + v); 16 | }) 17 | .subscribe(System.out::println); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/HookThrowing.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.io.IOException; 4 | import java.lang.Thread.UncaughtExceptionHandler; 5 | 6 | import org.junit.*; 7 | 8 | import io.reactivex.Observable; 9 | import io.reactivex.plugins.RxJavaPlugins; 10 | 11 | public class HookThrowing { 12 | 13 | @Before 14 | public void before() { 15 | RxJavaPlugins.setErrorHandler(ex -> { 16 | UncaughtExceptionHandler h = Thread.currentThread().getUncaughtExceptionHandler(); 17 | Thread.currentThread().setUncaughtExceptionHandler((t, e) -> { 18 | Thread.currentThread().setUncaughtExceptionHandler(h); 19 | HookThrowing.sneakyThrow(ex); 20 | }); 21 | throw new RuntimeException("Fail up"); 22 | }); 23 | } 24 | 25 | @SuppressWarnings("unchecked") 26 | static void sneakyThrow(Throwable ex) throws E { 27 | throw (E)ex; 28 | } 29 | 30 | @After 31 | public void after() { 32 | RxJavaPlugins.reset(); 33 | } 34 | 35 | @Test 36 | public void test() { 37 | Observable.error(new IOException()) 38 | .subscribe(); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/Issue5104.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import io.reactivex.Observable; 6 | import io.reactivex.schedulers.Schedulers; 7 | import io.reactivex.subjects.PublishSubject; 8 | 9 | public final class Issue5104 { 10 | private Issue5104() { } 11 | 12 | public static void main(String[] args) throws Exception { 13 | PublishSubject vehicleToFetch = PublishSubject.create(); 14 | vehicleToFetch 15 | .delay(2,TimeUnit.SECONDS) 16 | .window(10, TimeUnit.SECONDS, 5) 17 | .observeOn(Schedulers.io()) 18 | .subscribe(w -> w.toList().subscribe(ws -> { 19 | ws.forEach(v -> { 20 | System.out.println(String.format("%s %d", v, Thread.currentThread().getId())); 21 | vehicleToFetch.onNext(v); 22 | }); 23 | })); 24 | 25 | 26 | Observable.just("v1","v2","v3","v4").subscribe(v -> vehicleToFetch.onNext(v)); 27 | 28 | Thread.sleep(15000); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ItemTestSO.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | 9 | public class ItemTestSO { 10 | 11 | static class ItemTest { 12 | int i; 13 | ItemTest(int i) { 14 | this.i = i; 15 | } 16 | @Override 17 | public String toString() { 18 | return "ItemTest " + i; 19 | } 20 | } 21 | 22 | @Test 23 | public void itemTest() { 24 | Observable.zip(Observable.interval(1, TimeUnit.SECONDS), 25 | Observable.range(1, 10).map(v -> new ItemTest(v)) 26 | , 27 | (a, b) -> b, false, 1) 28 | .concatWith(Observable.empty() 29 | .doOnSubscribe(s -> System.out.println("")) 30 | .delay(10, TimeUnit.SECONDS)) 31 | .blockingSubscribe(System.out::println); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/JustFlatMapCallableNull.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.*; 6 | 7 | public class JustFlatMapCallableNull { 8 | 9 | @Test 10 | public void test() { 11 | Observable.just(1).flatMap(i -> Observable.fromCallable(() -> null)) 12 | .test() 13 | .assertFailure(NullPointerException.class); 14 | } 15 | 16 | @Test 17 | public void test1() { 18 | Observable.just(1).hide().flatMap(i -> Observable.fromCallable(() -> null)) 19 | .test() 20 | .assertFailure(NullPointerException.class); 21 | } 22 | 23 | @Test 24 | public void test2() { 25 | Flowable.just(1).flatMap(i -> Flowable.fromCallable(() -> null)) 26 | .test() 27 | .assertFailure(NullPointerException.class); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/JustFromEagerCancel.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.Callable; 4 | import java.util.concurrent.atomic.AtomicInteger; 5 | 6 | import org.junit.*; 7 | 8 | import io.reactivex.Observable; 9 | 10 | public class JustFromEagerCancel { 11 | 12 | @Test 13 | public void test() { 14 | AtomicInteger cnt = new AtomicInteger(); 15 | 16 | Callable a = () -> cnt.incrementAndGet(); 17 | Observable.fromCallable(() -> a) 18 | .map(v -> v.call()) 19 | .test(true) 20 | .assertEmpty(); 21 | 22 | Assert.assertEquals(0, cnt.get()); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/LastZipped.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Flowable; 6 | import io.reactivex.processors.PublishProcessor; 7 | import io.reactivex.subscribers.TestSubscriber; 8 | 9 | public class LastZipped { 10 | 11 | @Test 12 | public void test() { 13 | PublishProcessor pp1 = PublishProcessor.create(); 14 | PublishProcessor pp2 = PublishProcessor.create(); 15 | 16 | TestSubscriber ts = Flowable.zip(pp1.last(1).toFlowable(), pp2.last(2).toFlowable(), (a, b) -> a + b) 17 | .test(); 18 | 19 | pp1.onNext(3); 20 | pp1.onComplete(); 21 | pp2.onComplete(); 22 | 23 | ts.assertResult(5); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/LatestObserveOnTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Flowable; 8 | import io.reactivex.internal.subscriptions.BooleanSubscription; 9 | import io.reactivex.schedulers.Schedulers; 10 | import io.reactivex.subscribers.TestSubscriber; 11 | 12 | public class LatestObserveOnTest { 13 | 14 | @Test 15 | public void test() throws Exception { 16 | for (int i = 0; i < 1000; i++) { 17 | TestSubscriber ts = new TestSubscriber<>(); 18 | ts.onSubscribe(new BooleanSubscription()); 19 | Flowable.range(1, 100) 20 | .onBackpressureLatest() 21 | .observeOn(Schedulers.io(), false, 1) 22 | .subscribe(v -> { 23 | Thread.sleep(100); 24 | ts.onNext(v); 25 | }, ts::onError, ts::onComplete); 26 | 27 | ts.awaitDone(5, TimeUnit.SECONDS) 28 | .assertResult(1, 100); 29 | } 30 | Thread.sleep(1000); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ListFlattening.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.ArrayList; 4 | 5 | import org.junit.Test; 6 | 7 | import rx.Observable; 8 | 9 | public class ListFlattening { 10 | 11 | static class User { } 12 | 13 | Observable getUserDetails(User u) { 14 | return Observable.empty(); 15 | } 16 | 17 | @Test 18 | public void test() { 19 | Observable> users = Observable.just(new ArrayList<>()); 20 | 21 | users.flatMapIterable(list -> list) 22 | .flatMap(user -> getUserDetails(user)) 23 | .subscribe(user -> { /* ... */ }, Throwable::printStackTrace); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/MatchIndex.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.*; 6 | import io.reactivex.functions.Predicate; 7 | 8 | public class MatchIndex { 9 | 10 | @Test 11 | public void test() { 12 | Observable.range(1, 10) 13 | .compose(indexOf(v -> v == 5)) 14 | .subscribe(System.out::println); 15 | 16 | Observable.range(1, 10) 17 | .compose(indexOf(v -> v == 12)) 18 | .subscribe(System.out::println); 19 | } 20 | 21 | static ObservableTransformer indexOf(Predicate predicate) { 22 | return o -> Observable.defer(() -> { 23 | int[] index = { -1, -1 }; 24 | return o.filter(v -> { 25 | index[0]++; 26 | if (predicate.test(v)) { 27 | index[1] = index[0]; 28 | return true; 29 | } 30 | return false; 31 | }) 32 | .takeWhile(v -> index[1] != -1) 33 | .ignoreElements() 34 | .andThen(Observable.fromCallable(() -> index[1])); 35 | }); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/MaxByTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Flowable; 6 | 7 | public class MaxByTest { 8 | 9 | @Test 10 | public void test() { 11 | Flowable.fromArray("a", "bb", "ccc", "d", "eee", "ffff") 12 | .reduce((last, current) -> 13 | Integer.compare(last.length(), current.length()) >= 0 14 | ? last : current) 15 | .subscribe(System.out::println); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/MergeAmbTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import static org.junit.Assert.assertEquals; 4 | 5 | import java.util.concurrent.TimeUnit; 6 | 7 | import org.junit.Test; 8 | 9 | import io.reactivex.Observable; 10 | import io.reactivex.observers.TestObserver; 11 | 12 | public class MergeAmbTest { 13 | 14 | @Test 15 | public void testMergeOperator() { 16 | TestObserver observer = new TestObserver<>(); 17 | 18 | Observable foo = Observable.just("FOO"); 19 | Observable bar = Observable.timer(2, TimeUnit.SECONDS).map(v -> "BAR"); 20 | 21 | foo.publish(first -> Observable.merge(first, bar.takeUntil(first)) 22 | .firstOrError() 23 | .toObservable()) 24 | .subscribe(observer); 25 | 26 | assertEquals(1, observer.valueCount()); 27 | assertEquals("FOO", observer.values().get(0)); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/MonoPublishTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import io.reactivex.Flowable; 4 | 5 | public final class MonoPublishTest { 6 | 7 | private MonoPublishTest() { } 8 | 9 | public static void main(String[] args) { 10 | /* 11 | Mono simpleMono = Mono.just(1); 12 | Mono publishMulticastMono = simpleMono.publish(m -> m); 13 | Flux> fluxThatHasPublishMulticastMonos = Flux.just(publishMulticastMono); 14 | 15 | publishMulticastMono.block(); 16 | 17 | fluxThatHasPublishMulticastMonos 18 | .flatMap(mono -> mono) // flatten 19 | .blockLast(); // fire. Note: No problem with `blockFirst()` 20 | */ 21 | Flowable source = Flowable.just(1); 22 | Flowable> s2 = Flowable.just(source.publish(v -> v)); 23 | 24 | s2.flatMap(v -> v).blockingLast(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/MultiplyDigits.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.math.BigInteger; 4 | 5 | import org.junit.Test; 6 | 7 | public class MultiplyDigits { 8 | 9 | @Test 10 | public void test() { 11 | BigInteger number = new BigInteger("277777788888899"); 12 | BigInteger ten = new BigInteger("10"); 13 | 14 | System.out.println(number); 15 | 16 | int j = 1; 17 | 18 | while (number.compareTo(ten) > 0) { 19 | 20 | String s = number.toString(); 21 | 22 | BigInteger newNum = new BigInteger(s.substring(0, 1)); 23 | 24 | for (int i = 1; i < s.length(); i++) { 25 | newNum = newNum.multiply(new BigInteger(s.substring(i, i + 1))); 26 | } 27 | 28 | System.out.print(j++); 29 | System.out.print(": "); 30 | System.out.println(newNum); 31 | 32 | number = newNum; 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/NotInFirst.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.HashSet; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | 9 | public class NotInFirst { 10 | 11 | @Test 12 | public void test() { 13 | Observable obs1 = Observable.range(1, 10); 14 | Observable obs2 = Observable.range(5, 10); 15 | 16 | obs1.collect(HashSet::new, (a, b) -> a.add(b)) 17 | .flatMapObservable(set -> 18 | obs2.filter(set::contains) 19 | ) 20 | .subscribe(System.out::println); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ObservableConcatEagerTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.ThreadLocalRandom; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | import io.reactivex.schedulers.Schedulers; 9 | 10 | public class ObservableConcatEagerTest { 11 | 12 | @Test 13 | public void test() { 14 | //Set set = Ix.range(1, 1_000_000).toSet(); 15 | 16 | Observable.range(1, 100000) 17 | .buffer(10) 18 | .concatMapEager(value -> Observable.just(value) 19 | .subscribeOn(Schedulers.io()) 20 | .doOnNext(it -> Thread.sleep(ThreadLocalRandom.current().nextLong(10, 100))), 21 | 3, 4) 22 | .blockingSubscribe(it -> System.out.println("Received : " + it)); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ObservableOnSubscribeTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import io.reactivex.*; 4 | 5 | public class ObservableOnSubscribeTest { 6 | public static void main(String[] args) { 7 | Observable.create( 8 | new ObservableOnSubscribe(){ 9 | @Override 10 | public void subscribe(ObservableEmitter sub){ 11 | sub.onNext("New Datas"); 12 | sub.onComplete(); 13 | } 14 | } 15 | ); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/OnErrorCrash.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Single; 6 | import io.reactivex.schedulers.Schedulers; 7 | 8 | public class OnErrorCrash { 9 | 10 | @Test 11 | public void test() throws Exception { 12 | Single.fromCallable(() -> { throw new RuntimeException(); }) 13 | .subscribeOn(Schedulers.io()) 14 | .observeOn(Schedulers.computation()) 15 | .subscribe(v -> { }, e -> { throw new RuntimeException(e); }); 16 | 17 | Thread.sleep(50000); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/PSTestWithTS.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import static org.junit.Assert.assertEquals; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Scheduler; 8 | import io.reactivex.schedulers.TestScheduler; 9 | import io.reactivex.subjects.PublishSubject; 10 | 11 | public class PSTestWithTS { 12 | 13 | PublishSubject source = PublishSubject.create(); 14 | 15 | String value = "initial"; 16 | 17 | void prepare(Scheduler sub, Scheduler on) { 18 | source 19 | .subscribeOn(sub) 20 | .observeOn(on) 21 | .subscribe(v -> value = v); 22 | } 23 | 24 | @Test 25 | public void test() { 26 | String testString = "testString"; 27 | TestScheduler sch = new TestScheduler(); 28 | 29 | prepare(sch, sch); 30 | 31 | sch.triggerActions(); 32 | 33 | source.onNext(testString); 34 | 35 | sch.triggerActions(); 36 | 37 | assertEquals(testString, value); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ParallelFileProcessing.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.nio.file.*; 4 | import java.util.stream.Stream; 5 | 6 | import org.junit.Test; 7 | 8 | import io.reactivex.Flowable; 9 | import io.reactivex.schedulers.Schedulers; 10 | 11 | public class ParallelFileProcessing { 12 | 13 | @Test 14 | public void test() { 15 | //ParallelFlowable pf = 16 | Flowable.>using( 17 | () -> Files.list(Paths.get("/my/dir/with/files")), 18 | files -> Flowable.fromIterable((Iterable)() -> files.iterator()), 19 | AutoCloseable::close 20 | ) 21 | .parallel(2) 22 | .runOn(Schedulers.computation()) 23 | .filter(Files::isRegularFile); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ParallelInterrupt.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.io.IOException; 4 | import java.util.concurrent.TimeUnit; 5 | 6 | import io.reactivex.Flowable; 7 | import io.reactivex.plugins.RxJavaPlugins; 8 | import io.reactivex.schedulers.Schedulers; 9 | 10 | public final class ParallelInterrupt { 11 | 12 | private ParallelInterrupt() { } 13 | 14 | public static void main(String[] args) { 15 | RxJavaPlugins.setErrorHandler(e -> { }); 16 | Flowable.range(1, 10) 17 | .parallel(4) 18 | .runOn(Schedulers.io()) 19 | .map(v -> { 20 | if (v == 2) { 21 | throw new IOException(); 22 | } 23 | Thread.sleep(2000); 24 | return v; 25 | }) 26 | .sequential() 27 | .test() 28 | .awaitDone(5, TimeUnit.SECONDS) 29 | .assertFailure(IOException.class); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ParallelProducing.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.atomic.AtomicInteger; 4 | 5 | import io.reactivex.Maybe; 6 | import io.reactivex.schedulers.Schedulers; 7 | 8 | public class ParallelProducing { 9 | public static void main(String[] args) { 10 | AtomicInteger j = new AtomicInteger(0); 11 | AtomicInteger i = new AtomicInteger(0); 12 | Maybe maybeSource = Maybe.create(emitter -> emitter.onSuccess(i.incrementAndGet())); 13 | maybeSource 14 | .repeat() 15 | .parallel(30, 1) 16 | .runOn(Schedulers.io(), 1) 17 | .map(Object::toString) 18 | .sequential(1) 19 | .take(100) 20 | .blockingSubscribe(v -> System.out.println(j.incrementAndGet() + " - " + v)); 21 | 22 | System.out.println("Consumed: " + i.get()); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/PartialCollectTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import io.reactivex.Flowable; 4 | import io.reactivex.functions.Consumer; 5 | 6 | public class PartialCollectTest { 7 | 8 | interface PartialCollection { 9 | 10 | I partialIndex(); 11 | 12 | void partialIndex(I newIndex); 13 | 14 | int size(); 15 | 16 | T item(int index); 17 | 18 | void dropFront(int count); 19 | 20 | A accumulator(); 21 | 22 | void accumulator(A newAccumulator); 23 | 24 | void onNext(R output); 25 | } 26 | 27 | public static Flowable partialCollect(Consumer> collector) { 28 | throw new UnsupportedOperationException(); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/PeriodicSchedule.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.disposables.Disposable; 8 | import io.reactivex.schedulers.Schedulers; 9 | 10 | public class PeriodicSchedule { 11 | 12 | @Test 13 | public void test() throws Exception { 14 | final Disposable schedulePeriodicallyDirect = Schedulers.io().schedulePeriodicallyDirect(new Runnable() { 15 | private int val = 0; 16 | 17 | @Override 18 | public void run() { 19 | System.out.println("executed " + (val++)); 20 | } 21 | }, 1000, 1000, TimeUnit.MILLISECONDS); 22 | 23 | Thread.sleep(2500); 24 | schedulePeriodicallyDirect.dispose(); 25 | System.out.println("Disposed"); 26 | 27 | Thread.sleep(2500); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/PublishRefCountPublishTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.*; 4 | 5 | import io.reactivex.Flowable; 6 | import io.reactivex.subscribers.TestSubscriber; 7 | import reactor.core.publisher.Flux; 8 | 9 | public class PublishRefCountPublishTest { 10 | 11 | @Test 12 | public void test() { 13 | int[] calls = { 0 }; 14 | 15 | Flowable.range(1, 10) 16 | .doOnCancel(() -> calls[0]++) 17 | .publish() 18 | .refCount() 19 | .publish(v -> v) 20 | .take(5) 21 | .test() 22 | .assertResult(1, 2, 3, 4, 5); 23 | 24 | Assert.assertEquals(1, calls[0]); 25 | } 26 | 27 | @Test 28 | public void test2() { 29 | int[] calls = { 0 }; 30 | 31 | Flux.range(1, 10) 32 | .doOnCancel(() -> calls[0]++) 33 | .publish() 34 | .refCount() 35 | .publish(v -> v) 36 | .take(5) 37 | .subscribeWith(new TestSubscriber()) 38 | .assertResult(1, 2, 3, 4, 5); 39 | 40 | Assert.assertEquals(1, calls[0]); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/PublishUndeliverableTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.io.IOException; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | 9 | public class PublishUndeliverableTest { 10 | 11 | @Test 12 | public void test() { 13 | Observable.error(new IOException()) 14 | .publish(o -> { 15 | Observable cont = o.onErrorResumeNext((Throwable e) -> Observable.empty()); 16 | return Observable.mergeDelayError(o, cont); 17 | }) 18 | .onErrorResumeNext((Throwable e) -> Observable.just("bar")) 19 | .test() 20 | .assertResult("bar"); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ReentrantSubject.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.List; 4 | import java.util.concurrent.TimeUnit; 5 | 6 | import org.junit.Test; 7 | 8 | import io.reactivex.subjects.*; 9 | 10 | public class ReentrantSubject { 11 | static Subject publisher = PublishSubject.create().toSerialized(); 12 | 13 | @Test 14 | public void testReactive() throws Exception { 15 | publisher.buffer(100, TimeUnit.MILLISECONDS, 1) 16 | .doOnNext(System.out::println) 17 | .doOnNext(ReentrantSubject::fakeError) 18 | .subscribe(); 19 | 20 | publisher.onNext(0); 21 | 22 | Thread.sleep(100000); 23 | } 24 | 25 | private static void fakeError(List integers) { 26 | integers.forEach(publisher::onNext); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/RefCountRace.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | import io.reactivex.observers.TestObserver; 9 | import io.reactivex.schedulers.Schedulers; 10 | 11 | public class RefCountRace { 12 | @Test 13 | public void replayRefCountShallBeThreadSafe() { 14 | for (int i = 0; i < 10000; i++) { 15 | Observable observable = Observable.just(1).replay(1).refCount(); 16 | 17 | TestObserver observer1 = observable 18 | .subscribeOn(Schedulers.io()) 19 | .test(); 20 | 21 | TestObserver observer2 = observable 22 | .subscribeOn(Schedulers.io()) 23 | .test(); 24 | 25 | observer1 26 | .withTag("" + i) 27 | .awaitDone(5, TimeUnit.SECONDS) 28 | .assertResult(1); 29 | 30 | observer2 31 | .withTag("" + i) 32 | .awaitDone(5, TimeUnit.SECONDS) 33 | .assertResult(1); 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/RepeatThread.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import io.reactivex.Flowable; 4 | import io.reactivex.schedulers.Schedulers; 5 | 6 | public class RepeatThread { 7 | 8 | public static void main(String[] args) throws Exception { 9 | for (int i = 0; i < 100; i++) { 10 | Flowable.range(1, 5) 11 | .repeat() 12 | .map(v -> { 13 | System.out.println(Thread.currentThread()); 14 | // Thread.sleep(100); 15 | return v; 16 | }) 17 | .subscribeOn(Schedulers.single()) 18 | .take(10) 19 | .blockingSubscribe(); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ReplayOOM.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Flowable; 6 | 7 | public class ReplayOOM { 8 | 9 | static int i; 10 | 11 | @Test 12 | public void test() { 13 | Flowable.range(1, 5000) 14 | .map(__ -> new byte[1024 * 1024]) 15 | .replay( 16 | fb -> 17 | fb.take(1) 18 | .concatMap(__ -> fb) 19 | ,1 20 | ) 21 | .doOnNext(v -> { 22 | if (i++ == 1000) { 23 | System.out.println(""); 24 | } 25 | }) 26 | .count() 27 | .toFlowable() 28 | .blockingSubscribe(c -> System.out.println("args = [" + c + "]")); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/RetryWhenDelay.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | 9 | public class RetryWhenDelay { 10 | 11 | @Test 12 | public void test() throws Exception { 13 | Observable call = Observable.create(emitter -> { 14 | emitter.onNext(1); 15 | emitter.onError(new Throwable("Error")); 16 | }); 17 | 18 | call 19 | .retryWhen(throwableObservable -> throwableObservable.delay(1, TimeUnit.SECONDS)) 20 | .subscribe(integer -> System.out.println(integer), throwable -> System.out.println(throwable.getMessage())); 21 | 22 | Thread.sleep(10000); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/RxJava2Test.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | import java.util.Collections; 3 | 4 | import io.reactivex.*; 5 | 6 | public final class RxJava2Test { 7 | 8 | private RxJava2Test() { } 9 | 10 | public static void main(String... args) { 11 | Flowable source = Flowable.create((e) -> { 12 | for (int i = 0; i < 300; i++) { 13 | e.onNext(i); 14 | } 15 | e.onComplete(); 16 | }, BackpressureStrategy.BUFFER); 17 | Flowable cached = source.cache(); 18 | 19 | long sourceCount = source.concatMapIterable(Collections::singleton) 20 | .distinct().count().blockingGet(); 21 | long cachedCount = cached.concatMapIterable(Collections::singleton) 22 | .distinct().count().blockingGet(); 23 | 24 | System.out.println("source: " + sourceCount); 25 | System.out.println("cached: " + cachedCount); 26 | } 27 | } -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/RxWeakRef.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.lang.ref.WeakReference; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | 9 | public class RxWeakRef { 10 | 11 | @Test 12 | public void test() throws Exception { 13 | WeakReference wr = new WeakReference<>(123456789); 14 | 15 | Observable obs = Observable.fromCallable(() -> wr.get()); 16 | 17 | System.gc(); 18 | Thread.sleep(200); 19 | 20 | wr.getClass(); 21 | 22 | obs.test() 23 | .assertFailure(NullPointerException.class); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/SampleTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | 9 | public class SampleTest { 10 | 11 | @Test 12 | public void test() throws Exception { 13 | 14 | Observable.interval(50, TimeUnit.MILLISECONDS) 15 | .doOnNext(v -> { 16 | if (v % 20 == 0) { 17 | System.out.println("--------- second: " + v / 20); 18 | } 19 | }) 20 | .sample(200, TimeUnit.MILLISECONDS) 21 | .subscribe(System.out::println); 22 | 23 | Thread.sleep(5000); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ShareRace.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | import io.reactivex.observers.TestObserver; 9 | import io.reactivex.schedulers.Schedulers; 10 | 11 | public class ShareRace { 12 | 13 | @Test 14 | public void test() { 15 | for (int i = 0; i < 10_000; i++) { 16 | Observable observable = Observable.just(1).publish().refCount(); 17 | 18 | TestObserver observer1 = observable 19 | .subscribeOn(Schedulers.computation()) 20 | .test(); 21 | 22 | TestObserver observer2 = observable 23 | .subscribeOn(Schedulers.computation()) 24 | .test(); 25 | 26 | observer1 27 | .withTag("observer1 " + i) 28 | .awaitDone(5, TimeUnit.SECONDS) 29 | .assertNoErrors() 30 | .assertComplete(); 31 | 32 | observer2 33 | .withTag("observer2 " + i) 34 | .awaitDone(5, TimeUnit.SECONDS) 35 | .assertNoErrors() 36 | .assertComplete(); 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/SingleTakeUntilTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.CancellationException; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.*; 8 | 9 | public class SingleTakeUntilTest { 10 | 11 | @Test 12 | public void test() { 13 | Single.just(1).takeUntil(Flowable.just(1).take(1)) 14 | .test() 15 | .assertFailure(CancellationException.class); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/SingleTimeout7514.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.*; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Single; 8 | import io.reactivex.disposables.Disposable; 9 | import io.reactivex.schedulers.Schedulers; 10 | 11 | public class SingleTimeout7514 { 12 | 13 | @Test 14 | public void test() throws Exception { 15 | for (int i = 0; i < 10000000; i++) { 16 | final int y = i; 17 | final CountDownLatch latch = new CountDownLatch(1); 18 | Disposable d = Single.never() 19 | .timeout(0, TimeUnit.NANOSECONDS, Schedulers.computation()) 20 | .subscribe(v -> {}, e -> { 21 | System.out.println("timeout " + y); 22 | latch.countDown(); 23 | }); 24 | if (!latch.await(2, TimeUnit.SECONDS)) { 25 | System.out.println(d); 26 | throw new IllegalStateException("Timeout was not happening!"); 27 | } 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/SingleTimeout7515Rx3.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.*; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.rxjava3.core.Single; 8 | import io.reactivex.rxjava3.disposables.Disposable; 9 | import io.reactivex.rxjava3.schedulers.Schedulers; 10 | 11 | 12 | public class SingleTimeout7515Rx3 { 13 | 14 | @Test 15 | public void test() throws Exception { 16 | for (int i = 0; i < 10000000; i++) { 17 | final int y = i; 18 | final CountDownLatch latch = new CountDownLatch(1); 19 | Disposable d = Single.never() 20 | .timeout(0, TimeUnit.NANOSECONDS, Schedulers.computation()) 21 | .subscribe(v -> {}, e -> { 22 | System.out.println("timeout " + y); 23 | latch.countDown(); 24 | }); 25 | if (!latch.await(2, TimeUnit.SECONDS)) { 26 | System.out.println(d); 27 | throw new IllegalStateException("Timeout was not happening!"); 28 | } 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/SingleUsingTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Single; 6 | 7 | public class SingleUsingTest { 8 | 9 | @Test 10 | public void test() { 11 | Single.just("input").flatMap(val -> 12 | Single.using( 13 | () -> { 14 | System.out.println("create"); 15 | return ""; 16 | }, 17 | call -> singleSubscriber -> { 18 | System.out.println("sub"); 19 | singleSubscriber.onSuccess(val); 20 | System.out.println("sub done"); 21 | }, 22 | call -> { 23 | System.out.println("close"); 24 | } 25 | ) 26 | .retry((count, error) -> { 27 | System.out.println("retry"); 28 | return true; 29 | }) 30 | ) 31 | .subscribe(val -> System.out.println("output " + val)); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/SlidingWindowTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Observable; 6 | 7 | public class SlidingWindowTest { 8 | 9 | @Test 10 | public void test() { 11 | Observable.range(1, 4) 12 | .buffer(2, 1) 13 | .filter(list -> list.size() == 2) 14 | .map(list -> list.get(0) + list.get(1)) 15 | .test() 16 | .assertResult(3, 5, 7); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/SortZip.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import static org.junit.Assert.assertEquals; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Flowable; 8 | import reactor.core.publisher.Flux; 9 | import reactor.util.function.Tuples; 10 | 11 | public class SortZip { 12 | 13 | @Test 14 | public void testRx() { 15 | for (int i = 1; i < 1000; i++) { 16 | final int j = i; 17 | Flowable.range(1, i).map(v -> j - v) 18 | .sorted() 19 | .zipWith(Flowable.range(1, Integer.MAX_VALUE), (a, b) -> Tuples.of(a, b)) 20 | .toList() 21 | .map(list -> list.size()) 22 | .test() 23 | .assertResult(i); 24 | } 25 | } 26 | 27 | @Test 28 | public void testReactor() { 29 | for (int i = 1; i < 1000; i++) { 30 | final int j = i; 31 | int k = Flux.range(1, i).map(v -> j - v) 32 | .sort() 33 | .zipWith(Flux.range(1, Integer.MAX_VALUE), (a, b) -> Tuples.of(a, b)) 34 | .collectList() 35 | .map(list -> list.size()) 36 | .block(); 37 | assertEquals(j, k); 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/SubjectShareTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Observable; 6 | import io.reactivex.subjects.PublishSubject; 7 | 8 | public class SubjectShareTest { 9 | enum Request { 10 | Request1, 11 | Request2 12 | } 13 | 14 | @Test 15 | public void test() { 16 | PublishSubject requestStream = PublishSubject.create(); 17 | 18 | Observable stateChanges = requestStream.share(); 19 | 20 | stateChanges 21 | .delaySubscription(requestStream) 22 | .subscribe(v -> { System.out.println("received " + v); }); 23 | 24 | // Comment this and it changes the output! 25 | stateChanges.subscribe(); 26 | 27 | requestStream.onNext(Request.Request1); 28 | requestStream.onNext(Request.Request2); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/SwitchFallback.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.List; 4 | 5 | import io.reactivex.Observable; 6 | 7 | public class SwitchFallback { 8 | 9 | public static void main(String[] args) { 10 | Observable> source = Observable.empty(); 11 | 12 | Observable> fallbackSource = Observable.empty(); 13 | 14 | source.flatMap(list -> { 15 | if (list.isEmpty()) { 16 | return fallbackSource; 17 | } 18 | return Observable.just(list); 19 | }); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/SwitchIfFewerTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.*; 6 | 7 | public class SwitchIfFewerTest { 8 | 9 | @Test 10 | public void test() { 11 | Observable.range(1, 5) 12 | .compose(switchIfFewer(Observable.range(1, 8), 10)) 13 | .compose(switchIfFewer(Observable.range(1, 15), 10)) 14 | .test() 15 | .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); 16 | } 17 | 18 | static ObservableTransformer switchIfFewer(Observable other, int n) { 19 | return o -> { 20 | return o.toList() 21 | .flatMapObservable(list -> { 22 | if (list.size() < n) { 23 | return other; 24 | } 25 | return Observable.fromIterable(list); 26 | }); 27 | }; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/TakeUntil.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Single; 8 | import io.reactivex.disposables.Disposable; 9 | import io.reactivex.subjects.PublishSubject; 10 | 11 | @SuppressWarnings({ "unchecked", "rawtypes"}) 12 | public class TakeUntil { 13 | @Test 14 | public void test() { 15 | PublishSubject publishSubject = PublishSubject.create(); 16 | 17 | Disposable disposable = Single.timer(1000 * 2, TimeUnit.MILLISECONDS) 18 | .takeUntil(publishSubject.firstOrError()) 19 | .subscribe( 20 | data -> System.out.println("ted"), 21 | throwable -> System.err.println("ted" + throwable.toString()) 22 | ); 23 | disposable.dispose(); 24 | 25 | publishSubject.onNext(1); // emit end of lifecycle 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/TakeUntilTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Observable; 6 | 7 | public class TakeUntilTest { 8 | 9 | @Test 10 | public void test() { 11 | Observable.just(1,2,3,4,-1,1,2,3,4) 12 | .takeUntil(value -> value == -1) 13 | .subscribe(System.out::println); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/TestLazy.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | import io.reactivex.Flowable; 3 | 4 | public class TestLazy { 5 | public static void main(String[] args) { 6 | Flowable.just(1, 2, 3) 7 | .filter(s -> s > 4) 8 | .zipWith(Flowable.defer(() -> Flowable.just(get1(), get2(), get3())), (a, b) -> a + b) 9 | .subscribe(System.out::println); 10 | 11 | Flowable.just(1, 2, 3) 12 | .filter(s -> s > 4) 13 | .flatMap(a -> Flowable.defer(() -> Flowable.just(fromFlatMap()))) 14 | .subscribe(System.out::println); 15 | } 16 | 17 | private static int fromFlatMap() { 18 | System.out.println("from flatMap"); 19 | return 0; 20 | } 21 | 22 | private static int get1() { 23 | System.out.println("get 1"); 24 | return 1; 25 | } 26 | 27 | private static int get2() { 28 | System.out.println("get 2"); 29 | return 2; 30 | } 31 | 32 | private static int get3() { 33 | System.out.println("get 3"); 34 | return 3; 35 | } 36 | } -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/TestMockitoCalls.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import static org.mockito.Mockito.*; 4 | 5 | import java.util.List; 6 | 7 | import org.junit.Test; 8 | 9 | import io.reactivex.subjects.CompletableSubject; 10 | 11 | public class TestMockitoCalls { 12 | 13 | @Test 14 | public void test() { 15 | @SuppressWarnings("unchecked") 16 | List list = mock(List.class); 17 | 18 | CompletableSubject source = CompletableSubject.create(); 19 | 20 | source.doOnSubscribe(v -> list.add(1)) 21 | .doOnError(e -> list.remove(1)) 22 | .doOnComplete(() -> list.remove(1)) 23 | .subscribe(); 24 | 25 | source.onComplete(); 26 | 27 | verify(list).add(1); 28 | verify(list).remove(1); 29 | verifyNoMoreInteractions(list); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/TestObserverDispose.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.*; 4 | 5 | import io.reactivex.Observable; 6 | import io.reactivex.observers.TestObserver; 7 | 8 | public class TestObserverDispose { 9 | @Test 10 | public void observerShouldBeDisposed() { 11 | TestObserver observer = new TestObserver<>(); 12 | Observable.just("").subscribe(observer); 13 | observer.awaitTerminalEvent(); 14 | 15 | observer.assertNoErrors(); 16 | observer.assertComplete(); 17 | Assert.assertTrue(observer.isDisposed()); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ThrottleLastLeak.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import io.reactivex.disposables.Disposable; 6 | import io.reactivex.subjects.PublishSubject; 7 | 8 | public class ThrottleLastLeak { 9 | 10 | public static void main(String[] args) throws Exception { 11 | Disposable d = PublishSubject.create() 12 | .throttleLast(100, TimeUnit.MILLISECONDS) 13 | .subscribe(System.out::println); 14 | 15 | Thread.sleep(10000); 16 | 17 | d.dispose(); 18 | 19 | Thread.sleep(1000000); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ThrottleLastSO.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | import io.reactivex.observers.TestObserver; 9 | import io.reactivex.schedulers.TestScheduler; 10 | 11 | public class ThrottleLastSO { 12 | 13 | @Test 14 | public void test() { 15 | TestScheduler ts = new TestScheduler(); 16 | 17 | TestObserver to = Observable.error(new RuntimeException()) 18 | .onErrorReturnItem(0) 19 | .startWith(-1) 20 | .throttleLast(50, TimeUnit.MILLISECONDS, ts) 21 | .test(); 22 | 23 | ts.advanceTimeBy(1, TimeUnit.SECONDS); 24 | 25 | to.assertResult(0); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ThrowsSubclass.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | public class ThrowsSubclass { 4 | 5 | interface F { 6 | void m() throws Throwable; 7 | } 8 | 9 | public static void main(String[] args) { 10 | new F() { 11 | @Override 12 | public void m() throws Exception { 13 | 14 | } 15 | }; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/Timeout800Test.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | import io.reactivex.schedulers.Schedulers; 9 | 10 | public class Timeout800Test { 11 | 12 | @Test 13 | public void test() throws Exception { 14 | Observable.fromCallable(() -> { 15 | Thread.sleep(1000); 16 | return 1; 17 | }) 18 | .timeout(800, TimeUnit.MILLISECONDS) 19 | .subscribeOn(Schedulers.io()) 20 | .onErrorReturn(throwable -> { 21 | System.out.printf("Server did not respond within %s ms for id=%s%n", 800, 1); 22 | return 2; 23 | }) 24 | .subscribe(); 25 | 26 | Thread.sleep(2000); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/TimeoutExample.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | 9 | public class TimeoutExample { 10 | 11 | @Test 12 | public void test() { 13 | Observable source = Observable.create(emitter -> { 14 | emitter.onNext("A"); 15 | Thread.sleep(800); 16 | emitter.onNext("B"); 17 | Thread.sleep(400); 18 | emitter.onNext("C"); 19 | Thread.sleep(1200); 20 | emitter.onNext("D"); 21 | emitter.onComplete(); 22 | }); 23 | source.timeout(1, TimeUnit.SECONDS) 24 | .subscribe( 25 | item -> System.out.println("onNext: " + item), 26 | error -> System.out.println("onError: " + error), 27 | () -> System.out.println("onComplete will not be printed!")); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/TimeoutTask.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.*; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.*; 8 | import io.reactivex.schedulers.Schedulers; 9 | 10 | public class TimeoutTask { 11 | 12 | @Test 13 | public void test() { 14 | Observable source = Observable.create( 15 | (ObservableEmitter> emitter) -> { 16 | emitter.onNext(() -> task(0, "A")); 17 | emitter.onNext(() -> task(2, "B")); // this one times out 18 | emitter.onNext(() -> task(0, "C")); 19 | emitter.onNext(() -> task(0, "D")); 20 | emitter.onComplete(); 21 | }) 22 | .concatMap(call -> 23 | Observable.fromCallable(call) 24 | .subscribeOn(Schedulers.computation()) 25 | .timeout(1, TimeUnit.SECONDS, Observable.just("timeout")) 26 | ); 27 | 28 | source 29 | .blockingSubscribe(s -> System.out.println("RECEIVED: " + s)); 30 | } 31 | 32 | static String task(int i, String s) { 33 | return i + " " + s; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/UncaughtCrash.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.io.IOException; 4 | 5 | import org.junit.*; 6 | 7 | import io.reactivex.plugins.RxJavaPlugins; 8 | 9 | public class UncaughtCrash { 10 | 11 | @Before 12 | public void before() { 13 | RxJavaPlugins.setErrorHandler(e -> { 14 | Thread.currentThread().setUncaughtExceptionHandler((t, f) -> { 15 | Thread.currentThread().setUncaughtExceptionHandler(null); 16 | throw (InternalError)f; 17 | }); 18 | throw new InternalError(e); 19 | }); 20 | } 21 | 22 | @After 23 | public void after() { 24 | RxJavaPlugins.setErrorHandler(null); 25 | } 26 | 27 | @Test(expected = InternalError.class) 28 | public void test1() { 29 | RxJavaPlugins.onError(new IOException()); 30 | } 31 | 32 | @Test(expected = InternalError.class) 33 | public void test2() { 34 | RxJavaPlugins.onError(new IOException()); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/WindowInterrupted.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.Observable; 8 | 9 | public class WindowInterrupted { 10 | 11 | @Test 12 | public void test() { 13 | Observable 14 | .intervalRange(0, 2, 0, 1, TimeUnit.SECONDS) 15 | .window(1, TimeUnit.SECONDS) 16 | .doOnNext(i -> { 17 | long start = System.currentTimeMillis(); 18 | while (System.currentTimeMillis() < start+1500) { 19 | } 20 | if (Thread.interrupted()) { 21 | System.out.println("WTF? Thread is interrupted! " + Thread.currentThread()); 22 | } 23 | }) 24 | .ignoreElements() 25 | .blockingAwait(); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ZipInfinite.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.Flowable; 6 | import io.reactivex.processors.*; 7 | 8 | public class ZipInfinite { 9 | 10 | @Test 11 | public void test() { 12 | final Flowable flo1 = Flowable.just(1).repeat(); 13 | final FlowableProcessor flo2 = PublishProcessor.create(); 14 | final Flowable result = Flowable.zip(flo2, flo1, (o1, o2) -> { 15 | return 1; 16 | }, true, 1); 17 | result.subscribe(e -> System.out.println(e)); 18 | flo2.onNext(2); 19 | flo2.onNext(3); 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava2/ZipShare.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava2; 2 | 3 | import org.apache.commons.lang3.tuple.Pair; 4 | import org.junit.Test; 5 | 6 | import io.reactivex.Observable; 7 | 8 | public class ZipShare { 9 | 10 | @Test 11 | public void test() { 12 | Observable myObservable = Observable.just(1) 13 | .flatMap(i -> { 14 | throw new IllegalStateException(); 15 | }).share(); 16 | 17 | myObservable 18 | .zipWith(myObservable, Pair::of) 19 | .subscribe(pair -> { 20 | //ignore 21 | }, throwable -> { 22 | //ignore 23 | }); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava3/BufferStartStop2.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava3; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.rxjava3.core.Observable; 6 | 7 | 8 | public class BufferStartStop2 { 9 | 10 | @Test 11 | public void test() { 12 | Observable 13 | .fromArray(1,2,3,2,4,5,0,2,1,3,4,5,2,2,1,4,5) 14 | .publish(v -> v.buffer( 15 | v.filter(w -> w == 1), 16 | u -> v.filter(w -> w == 5)) 17 | ) 18 | .subscribe(System.out::println); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava3/CompletableAndThenNoError.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava3; 2 | 3 | import io.reactivex.rxjava3.core.Completable; 4 | import io.reactivex.rxjava3.core.Observable; 5 | 6 | public class CompletableAndThenNoError { 7 | 8 | public static void main(String[] args) { 9 | 10 | Completable.error(new Exception()) 11 | .toObservable() 12 | .flatMap( 13 | v -> Observable.never(), 14 | e -> Observable.just(false), 15 | () -> Observable.just(true) 16 | ) 17 | .subscribe(System.out::println); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava3/Issue7502.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava3; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.rxjava3.core.*; 6 | import io.reactivex.rxjava3.schedulers.Schedulers; 7 | 8 | public class Issue7502 { 9 | 10 | @Test 11 | public void test() { 12 | Flowable 13 | .just("") 14 | .repeat(5) 15 | .flatMap(singleIpHostAddress -> 16 | Flowable.create(o -> { 17 | throw new RuntimeException("test exception"); 18 | /* 19 | if (!o.isCancelled()) { 20 | o.onNext(""); 21 | o.onComplete(); 22 | } 23 | */ 24 | }, BackpressureStrategy.BUFFER) 25 | .subscribeOn(Schedulers.io()) 26 | .retry(50) 27 | ) 28 | .blockingSubscribe(v -> { 29 | System.out.println("onSuccess"); 30 | },v -> { 31 | System.out.println("onError"); 32 | }); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava3/NestedUsing.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava3; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.rxjava3.core.Single; 6 | 7 | public class NestedUsing { 8 | 9 | @Test 10 | public void test() { 11 | for (int i = 0; i < 2; i++) { 12 | int i0 = i; 13 | for (int j = 0; j < 2; j++) { 14 | int j0 = j; 15 | 16 | System.out.println("---"); 17 | System.out.printf("Outer: %s, Inner %s%n", i == 0, j == 0); 18 | 19 | Single.using(() -> 1, v -> 20 | Single.using(() -> 2, 21 | w -> Single.just(1), 22 | w -> System.out.println("Inner release, eager: " + (j0 == 0)), 23 | j0 == 0), 24 | v -> System.out.println("Outer release, eager: " + (i0 == 0)), 25 | i == 0 26 | ) 27 | .blockingSubscribe(); 28 | } 29 | } 30 | } 31 | 32 | } 33 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava3/RangeDelayedRange.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava3; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import io.reactivex.rxjava3.core.Flowable; 6 | import io.reactivex.rxjava3.schedulers.Schedulers; 7 | 8 | public class RangeDelayedRange { 9 | public static void main(String[] args) { 10 | Flowable.range(0, 20) 11 | .doOnNext(run -> System.out.println("run: " + run)) 12 | .concatMap(run -> Flowable.range(0, 1000) 13 | .flatMap(RangeDelayedRange::stubFunction) 14 | .doOnNext(iteration -> System.out.println("iteration: " + iteration)) 15 | .subscribeOn(Schedulers.io()) 16 | ) 17 | .count() 18 | .blockingSubscribe(v -> System.out.printf("%n%n---------%n%s", v)); 19 | } 20 | 21 | private static Flowable stubFunction(int iteration) { 22 | return Flowable.just(iteration) 23 | .delay(100, TimeUnit.MILLISECONDS); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava3/SchedulerPrint.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava3; 2 | 3 | import static org.junit.Assert.assertNotEquals; 4 | 5 | import java.util.concurrent.CountDownLatch; 6 | 7 | import org.testng.annotations.Test; 8 | 9 | import io.reactivex.rxjava3.disposables.Disposable; 10 | import io.reactivex.rxjava3.schedulers.Schedulers; 11 | 12 | public class SchedulerPrint { 13 | 14 | @Test 15 | public void disposablePrint() { 16 | CountDownLatch cdl = new CountDownLatch(1); 17 | try { 18 | Disposable d = Schedulers.single().scheduleDirect(() -> { 19 | try { 20 | cdl.await(); 21 | } catch (InterruptedException e) { 22 | e.printStackTrace(); 23 | } 24 | }); 25 | 26 | assertNotEquals("", d.toString()); 27 | } finally { 28 | cdl.countDown(); 29 | } 30 | } 31 | 32 | } 33 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava3/SomeBlocking.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava3; 2 | 3 | import org.junit.Test; 4 | 5 | import io.reactivex.rxjava3.core.Observable; 6 | import io.reactivex.rxjava3.schedulers.Schedulers; 7 | 8 | public class SomeBlocking { 9 | 10 | @Test 11 | public void test() { 12 | Observable 13 | .range(1, 20) 14 | .flatMap( 15 | integer -> { 16 | if (integer % 5 != 0) { 17 | return Observable 18 | .just(integer); 19 | } 20 | 21 | return Observable 22 | .just(-integer) 23 | .observeOn(Schedulers.io()); 24 | }, 25 | false, 26 | 1 27 | ) 28 | .ignoreElements() 29 | .blockingAwait(); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava3/UndeliverableTest.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava3; 2 | 3 | import java.io.IOException; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.rxjava3.plugins.RxJavaPlugins; 8 | import io.reactivex.rxjava3.processors.PublishProcessor; 9 | import io.reactivex.rxjava3.subscribers.TestSubscriber; 10 | 11 | public class UndeliverableTest { 12 | 13 | @Test 14 | public void test() { 15 | RxJavaPlugins.setErrorHandler(error -> System.out.println(error)); 16 | 17 | PublishProcessor main = PublishProcessor.create(); 18 | PublishProcessor inner = PublishProcessor.create(); 19 | 20 | // switchMapDelayError will delay all errors 21 | TestSubscriber ts = main.switchMapDelayError(v -> inner).test(); 22 | 23 | main.onNext(1); 24 | 25 | // the inner fails 26 | inner.onError(new IOException()); 27 | 28 | // the consumer is still clueless 29 | ts.assertEmpty(); 30 | 31 | // the consumer cancels 32 | ts.cancel(); 33 | 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava3/ZipPattern.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava3; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.apache.commons.math3.util.Pair; 6 | import org.junit.Test; 7 | 8 | import io.reactivex.rxjava3.core.Observable; 9 | 10 | public class ZipPattern { 11 | 12 | @Test 13 | public void test() { 14 | Observable 15 | .zip(Observable.just(-1L).concatWith(Observable.interval(10, 5, TimeUnit.SECONDS)), 16 | Observable.range(1, 5), 17 | (aLong, integer1) -> { 18 | return new Pair(aLong, integer1); 19 | } 20 | ) 21 | .concatMap(longIntegerPair -> { 22 | System.out.println("DATA " + longIntegerPair.getValue()); 23 | return Observable.just(longIntegerPair.getValue()) 24 | .delay(longIntegerPair.getKey() < 0 ? 10 : 5, TimeUnit.SECONDS) 25 | .flatMap(value -> { 26 | System.out.println("[performing operation] " + value); 27 | return Observable.just(value); 28 | }); 29 | }) 30 | .toList() 31 | .toObservable() 32 | .blockingSubscribe(); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/rxjava3/ZipWithOne.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.rxjava3; 2 | 3 | import java.util.concurrent.TimeUnit; 4 | 5 | import org.junit.Test; 6 | 7 | import io.reactivex.rxjava3.core.Flowable; 8 | 9 | public class ZipWithOne { 10 | 11 | @Test 12 | public void test() { 13 | Flowable integerFlowable = Flowable.just(1, 2, 3); 14 | Flowable delayedFlowable = Flowable.just(10).delay(1, TimeUnit.SECONDS).cache(); 15 | 16 | integerFlowable.concatMap(main -> delayedFlowable.map(other -> Integer.sum(main, other))) 17 | .test() 18 | .awaitDone(5, TimeUnit.SECONDS) 19 | .assertResult(11, 12, 13); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/test/java/hu/akarnokd/utils/TestException.java: -------------------------------------------------------------------------------- 1 | package hu.akarnokd.utils; 2 | 3 | /** 4 | * Exception for testing if unchecked expections propagate as-is without confusing with 5 | * other type of common exceptions. 6 | */ 7 | public final class TestException extends RuntimeException { 8 | 9 | private static final long serialVersionUID = -1438148770465406172L; 10 | 11 | /** 12 | * Constructs a TestException without message or cause. 13 | */ 14 | public TestException() { 15 | super(); 16 | } 17 | 18 | /** 19 | * Counstructs a TestException with message and cause. 20 | * @param message the message 21 | * @param cause the cause 22 | */ 23 | public TestException(String message, Throwable cause) { 24 | super(message, cause); 25 | } 26 | 27 | /** 28 | * Constructs a TestException with a message only. 29 | * @param message the message 30 | */ 31 | public TestException(String message) { 32 | super(message); 33 | } 34 | 35 | /** 36 | * Constructs a TestException with a cause only. 37 | * @param cause the cause 38 | */ 39 | public TestException(Throwable cause) { 40 | super(cause); 41 | } 42 | } 43 | --------------------------------------------------------------------------------