content_type
stringclasses 8
values | main_lang
stringclasses 7
values | message
stringlengths 1
50
| sha
stringlengths 40
40
| patch
stringlengths 52
962k
| file_count
int64 1
300
|
|---|---|---|---|---|---|
Python | Python | add widgets for datefield and datetimefield | 7bf03bbd66008b58d023de312378be17c0a7931d | <ide><path>rest_framework/fields.py
<ide> def __deepcopy__(self, memo):
<ide>
<ide> class DateField(WritableField):
<ide> type_name = 'DateField'
<add> widget = widgets.DateInput
<ide>
<ide> default_error_messages = {
<ide> 'invalid': _(u"'%s' value has an invalid date format. It must be "
<ide> def from_native(self, value):
<ide>
<ide> class DateTimeField(WritableField):
<ide> type_name = 'DateTimeField'
<add> widget = widgets.DateTimeInput
<ide>
<ide> default_error_messages = {
<ide> 'invalid': _(u"'%s' value has an invalid format. It must be in " | 1 |
Text | Text | add tom to the platform dev team 🎉 | 0463aae2f5dfb1b954bd816671dc354b95c669e2 | <ide><path>docs/README.md
<ide> When in doubt, you can reach out to our platform dev team to help you with this:
<ide> | Mrugesh Mohapatra | [@raisedadead](https://gitter.im/raisedadead) | [@raisedadead](https://twitter.com/raisedadead) |
<ide> | Ahmad Abdolsaheb | [@ahmadabdolsaheb](https://gitter.im/ahmadabdolsaheb) | [@Abdolsaheb](https://twitter.com/Abdolsaheb) |
<ide> | Kristofer Koishigawa | [@scissorsneedfoodtoo](https://gitter.im/scissorsneedfoodtoo) | [@kriskoishigawa](https://twitter.com/kriskoishigawa) |
<add>| Tom Mondloc | [@moT01](https://gitter.im/moT01) | - |
<ide>
<ide> **You can email our developer staff at: `dev[at]freecodecamp.org`** | 1 |
PHP | PHP | replace deprecated shoulddefermissing usages | ecb57fe678c3dcb0547053bc3429f49d09b03fad | <ide><path>tests/Database/DatabaseSoftDeletingScopeTest.php
<ide> public function testOnlyTrashedExtension()
<ide> m::mock(Processor::class)
<ide> ));
<ide> $model = m::mock(Model::class);
<del> $model->shouldDeferMissing();
<add> $model->makePartial();
<ide> $scope = m::mock(SoftDeletingScope::class.'[remove]');
<ide> $scope->extend($builder);
<ide> $callback = $builder->getMacro('onlyTrashed');
<ide> public function testWithoutTrashedExtension()
<ide> m::mock(Processor::class)
<ide> ));
<ide> $model = m::mock(Model::class);
<del> $model->shouldDeferMissing();
<add> $model->makePartial();
<ide> $scope = m::mock(SoftDeletingScope::class.'[remove]');
<ide> $scope->extend($builder);
<ide> $callback = $builder->getMacro('withoutTrashed');
<ide><path>tests/Database/DatabaseSoftDeletingTraitTest.php
<ide> public function tearDown()
<ide> public function testDeleteSetsSoftDeletedColumn()
<ide> {
<ide> $model = m::mock(DatabaseSoftDeletingTraitStub::class);
<del> $model->shouldDeferMissing();
<add> $model->makePartial();
<ide> $model->shouldReceive('newModelQuery')->andReturn($query = m::mock(stdClass::class));
<ide> $query->shouldReceive('where')->once()->with('id', 1)->andReturn($query);
<ide> $query->shouldReceive('update')->once()->with([
<ide> public function testDeleteSetsSoftDeletedColumn()
<ide> public function testRestore()
<ide> {
<ide> $model = m::mock(DatabaseSoftDeletingTraitStub::class);
<del> $model->shouldDeferMissing();
<add> $model->makePartial();
<ide> $model->shouldReceive('fireModelEvent')->with('restoring')->andReturn(true);
<ide> $model->shouldReceive('save')->once();
<ide> $model->shouldReceive('fireModelEvent')->with('restored', false)->andReturn(true);
<ide> public function testRestore()
<ide> public function testRestoreCancel()
<ide> {
<ide> $model = m::mock(DatabaseSoftDeletingTraitStub::class);
<del> $model->shouldDeferMissing();
<add> $model->makePartial();
<ide> $model->shouldReceive('fireModelEvent')->with('restoring')->andReturn(false);
<ide> $model->shouldReceive('save')->never();
<ide> | 2 |
Text | Text | add model card for google ai's bert miniatures | b2028cc26b61a9dad960274d427e261af7c9bdc8 | <ide><path>model_cards/iuliaturc/bert_uncased_L-2_H-128_A-2/README.md
<add>BERT Miniatures
<add>===
<add>
<add>This is the set of 24 BERT models referenced in [Well-Read Students Learn Better: On the Importance of Pre-training Compact Models](https://arxiv.org/abs/1908.08962) (English only, uncased, trained with WordPiece masking).
<add>
<add>We have shown that the standard BERT recipe (including model architecture and training objective) is effective on a wide range of model sizes, beyond BERT-Base and BERT-Large. The smaller BERT models are intended for environments with restricted computational resources. They can be fine-tuned in the same manner as the original BERT models. However, they are most effective in the context of knowledge distillation, where the fine-tuning labels are produced by a larger and more accurate teacher.
<add>
<add>Our goal is to enable research in institutions with fewer computational resources and encourage the community to seek directions of innovation alternative to increasing model capacity.
<add>
<add>You can download the 24 BERT miniatures either from the [official BERT Github page](https://github.com/google-research/bert/), or via HuggingFace from the links below:
<add>
<add>| |H=128|H=256|H=512|H=768|
<add>|---|:---:|:---:|:---:|:---:|
<add>| **L=2** |[**2/128 (BERT-Tiny)**][2_128]|[2/256][2_256]|[2/512][2_512]|[2/768][2_768]|
<add>| **L=4** |[4/128][4_128]|[**4/256 (BERT-Mini)**][4_256]|[**4/512 (BERT-Small)**][4_512]|[4/768][4_768]|
<add>| **L=6** |[6/128][6_128]|[6/256][6_256]|[6/512][6_512]|[6/768][6_768]|
<add>| **L=8** |[8/128][8_128]|[8/256][8_256]|[**8/512 (BERT-Medium)**][8_512]|[8/768][8_768]|
<add>| **L=10** |[10/128][10_128]|[10/256][10_256]|[10/512][10_512]|[10/768][10_768]|
<add>| **L=12** |[12/128][12_128]|[12/256][12_256]|[12/512][12_512]|[**12/768 (BERT-Base)**][12_768]|
<add>
<add>Note that the BERT-Base model in this release is included for completeness only; it was re-trained under the same regime as the original model.
<add>
<add>Here are the corresponding GLUE scores on the test set:
<add>
<add>|Model|Score|CoLA|SST-2|MRPC|STS-B|QQP|MNLI-m|MNLI-mm|QNLI(v2)|RTE|WNLI|AX|
<add>|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
<add>|BERT-Tiny|64.2|0.0|83.2|81.1/71.1|74.3/73.6|62.2/83.4|70.2|70.3|81.5|57.2|62.3|21.0|
<add>|BERT-Mini|65.8|0.0|85.9|81.1/71.8|75.4/73.3|66.4/86.2|74.8|74.3|84.1|57.9|62.3|26.1|
<add>|BERT-Small|71.2|27.8|89.7|83.4/76.2|78.8/77.0|68.1/87.0|77.6|77.0|86.4|61.8|62.3|28.6|
<add>|BERT-Medium|73.5|38.0|89.6|86.6/81.6|80.4/78.4|69.6/87.9|80.0|79.1|87.7|62.2|62.3|30.5|
<add>
<add>For each task, we selected the best fine-tuning hyperparameters from the lists below, and trained for 4 epochs:
<add>- batch sizes: 8, 16, 32, 64, 128
<add>- learning rates: 3e-4, 1e-4, 5e-5, 3e-5
<add>
<add>If you use these models, please cite the following paper:
<add>
<add>```
<add>@article{turc2019,
<add> title={Well-Read Students Learn Better: On the Importance of Pre-training Compact Models},
<add> author={Turc, Iulia and Chang, Ming-Wei and Lee, Kenton and Toutanova, Kristina},
<add> journal={arXiv preprint arXiv:1908.08962v2 },
<add> year={2019}
<add>}
<add>```
<add>
<add>[2_128]: https://huggingface.co/google/bert_uncased_L-2_H-128_A-2
<add>[2_256]: https://huggingface.co/google/bert_uncased_L-2_H-256_A-4
<add>[2_512]: https://huggingface.co/google/bert_uncased_L-2_H-512_A-8
<add>[2_768]: https://huggingface.co/google/bert_uncased_L-2_H-768_A-12
<add>[4_128]: https://huggingface.co/google/bert_uncased_L-4_H-128_A-2
<add>[4_256]: https://huggingface.co/google/bert_uncased_L-4_H-256_A-4
<add>[4_512]: https://huggingface.co/google/bert_uncased_L-4_H-512_A-8
<add>[4_768]: https://huggingface.co/google/bert_uncased_L-4_H-768_A-12
<add>[6_128]: https://huggingface.co/google/bert_uncased_L-6_H-128_A-2
<add>[6_256]: https://huggingface.co/google/bert_uncased_L-6_H-256_A-4
<add>[6_512]: https://huggingface.co/google/bert_uncased_L-6_H-512_A-8
<add>[6_768]: https://huggingface.co/google/bert_uncased_L-6_H-768_A-12
<add>[8_128]: https://huggingface.co/google/bert_uncased_L-8_H-128_A-2
<add>[8_256]: https://huggingface.co/google/bert_uncased_L-8_H-256_A-4
<add>[8_512]: https://huggingface.co/google/bert_uncased_L-8_H-512_A-8
<add>[8_768]: https://huggingface.co/google/bert_uncased_L-8_H-768_A-12
<add>[10_128]: https://huggingface.co/google/bert_uncased_L-10_H-128_A-2
<add>[10_256]: https://huggingface.co/google/bert_uncased_L-10_H-256_A-4
<add>[10_512]: https://huggingface.co/google/bert_uncased_L-10_H-512_A-8
<add>[10_768]: https://huggingface.co/google/bert_uncased_L-10_H-768_A-12
<add>[12_128]: https://huggingface.co/google/bert_uncased_L-12_H-128_A-2
<add>[12_256]: https://huggingface.co/google/bert_uncased_L-12_H-256_A-4
<add>[12_512]: https://huggingface.co/google/bert_uncased_L-12_H-512_A-8
<add>[12_768]: https://huggingface.co/google/bert_uncased_L-12_H-768_A-12 | 1 |
Javascript | Javascript | run property names through propfix in removeprop | 3ed4b22073767c17c099351637514f5928c0fd68 | <ide><path>src/attributes.js
<ide> jQuery.fn.extend({
<ide> },
<ide>
<ide> removeProp: function( name ) {
<add> name = jQuery.propFix[ name ] || name;
<ide> return this.each(function() {
<ide> // try/catch handles cases where IE balks (such as removing a property on window)
<ide> try { | 1 |
PHP | PHP | apply fixes from styleci | 8902690a87f87f516e298c6e00fa1dbf8a0224dd | <ide><path>tests/Database/DatabaseQueryBuilderTest.php
<ide> public function testCursorPaginateWithUnionWheres()
<ide> $builder->toSql());
<ide> $this->assertEquals([$ts], $builder->bindings['where']);
<ide> $this->assertEquals([$ts], $builder->bindings['union']);
<add>
<ide> return $results;
<ide> });
<ide>
<ide> public function testCursorPaginateWithUnionWheresWithRawOrderExpression()
<ide> $builder->toSql());
<ide> $this->assertEquals([true, $ts], $builder->bindings['where']);
<ide> $this->assertEquals([true, $ts], $builder->bindings['union']);
<add>
<ide> return $results;
<ide> });
<ide>
<ide> public function testCursorPaginateWithUnionWheresReverseOrder()
<ide> $builder->toSql());
<ide> $this->assertEquals([$ts], $builder->bindings['where']);
<ide> $this->assertEquals([$ts], $builder->bindings['union']);
<add>
<ide> return $results;
<ide> });
<ide>
<ide> public function testCursorPaginateWithUnionWheresReverseOrder()
<ide> ]), $result);
<ide> }
<ide>
<del> public function testCursorPaginateWithUnionWheresMultipleOrders()
<del> {
<add> public function testCursorPaginateWithUnionWheresMultipleOrders()
<add> {
<ide> $ts = now()->toDateTimeString();
<ide>
<ide> $perPage = 16;
<ide> public function testCursorPaginateWithUnionWheresMultipleOrders()
<ide> $builder->toSql());
<ide> $this->assertEquals([$ts, $ts, 1], $builder->bindings['where']);
<ide> $this->assertEquals([$ts, $ts, 1], $builder->bindings['union']);
<add>
<ide> return $results;
<ide> });
<ide> | 1 |
Python | Python | install all header files openssl-1.1.0 | 2b235830fb8bf387cce0449105877c30f6e5d44f | <ide><path>tools/install.py
<ide> def headers(action):
<ide> 'false' == variables.get('node_shared_openssl'):
<ide> subdir_files('deps/openssl/openssl/include/openssl', 'include/node/openssl/', action)
<ide> subdir_files('deps/openssl/config/archs', 'include/node/openssl/archs', action)
<del> action(['deps/openssl/config/opensslconf.h'], 'include/node/openssl/')
<add> subdir_files('deps/openssl/config', 'include/node/openssl', action)
<ide>
<ide> if 'false' == variables.get('node_shared_zlib'):
<ide> action([ | 1 |
Javascript | Javascript | remove all uses of executionenvironment.global | 426cdbb3aeca313784af25bff8bfb6d7ad7b1b38 | <ide><path>src/core/ReactEventTopLevelCallback.js
<ide>
<ide> "use strict";
<ide>
<del>var ExecutionEnvironment = require('ExecutionEnvironment');
<ide> var ReactEventEmitter = require('ReactEventEmitter');
<ide> var ReactMount = require('ReactMount');
<ide>
<ide> var ReactEventTopLevelCallback = {
<ide> }
<ide> var topLevelTarget = ReactMount.getFirstReactDOM(
<ide> getEventTarget(nativeEvent)
<del> ) || ExecutionEnvironment.global;
<add> ) || window;
<ide> var topLevelTargetID = ReactMount.getID(topLevelTarget) || '';
<ide> ReactEventEmitter.handleTopLevel(
<ide> topLevelType,
<ide><path>src/dom/getEventTarget.js
<ide>
<ide> "use strict";
<ide>
<del>var ExecutionEnvironment = require('ExecutionEnvironment');
<del>
<ide> /**
<ide> * Gets the target node from a native browser event by accounting for
<ide> * inconsistencies in browser DOM APIs.
<ide> var ExecutionEnvironment = require('ExecutionEnvironment');
<ide> * @return {DOMEventTarget} Target node.
<ide> */
<ide> function getEventTarget(nativeEvent) {
<del> var target =
<del> nativeEvent.target ||
<del> nativeEvent.srcElement ||
<del> ExecutionEnvironment.global;
<add> var target = nativeEvent.target || nativeEvent.srcElement || window;
<ide> // Safari may fire events on text nodes (Node.TEXT_NODE is 3).
<ide> // @see http://www.quirksmode.org/js/events_properties.html
<ide> return target.nodeType === 3 ? target.parentNode : target;
<ide><path>src/eventPlugins/EnterLeaveEventPlugin.js
<ide>
<ide> var EventConstants = require('EventConstants');
<ide> var EventPropagators = require('EventPropagators');
<del>var ExecutionEnvironment = require('ExecutionEnvironment');
<ide> var SyntheticMouseEvent = require('SyntheticMouseEvent');
<ide>
<ide> var ReactMount = require('ReactMount');
<ide> var EnterLeaveEventPlugin = {
<ide> from = topLevelTarget;
<ide> to =
<ide> getFirstReactDOM(nativeEvent.relatedTarget || nativeEvent.toElement) ||
<del> ExecutionEnvironment.global;
<add> window;
<ide> } else {
<del> from = ExecutionEnvironment.global;
<add> from = window;
<ide> to = topLevelTarget;
<ide> }
<ide>
<ide><path>src/test/ReactPerf.js
<ide> var ReactPerf = {
<ide>
<ide> if (__DEV__) {
<ide> var ExecutionEnvironment = require('ExecutionEnvironment');
<del> var URL = ExecutionEnvironment.global &&
<del> ExecutionEnvironment.global.location &&
<del> ExecutionEnvironment.global.location.href ||
<del> '';
<add> var URL = ExecutionEnvironment.canUseDOM ? window.location.href : '';
<ide> ReactPerf.enableMeasure = ReactPerf.enableMeasure ||
<ide> !!URL.match(/[?&]react_perf\b/);
<ide> }
<ide><path>src/vendor/core/ExecutionEnvironment.js
<ide> var ExecutionEnvironment = {
<ide>
<ide> canUseWorkers: typeof Worker !== 'undefined',
<ide>
<del> isInWorker: !canUseDOM, // For now, this is true - might change in the future.
<del>
<del> global: new Function('return this;')()
<add> isInWorker: !canUseDOM // For now, this is true - might change in the future.
<ide>
<ide> };
<ide> | 5 |
PHP | PHP | show warning if view already exists | ecb516445b06a15600f29e51738a409c2b9827ec | <ide><path>src/Illuminate/Foundation/Console/ComponentMakeCommand.php
<ide> protected function writeView()
<ide> $this->files->makeDirectory(dirname($path), 0777, true, true);
<ide> }
<ide>
<add> if ($this->files->exists($path) && ! $this->option('force')) {
<add> $this->warn('View already exists');
<add> return;
<add> }
<add>
<ide> file_put_contents(
<ide> $path.'.blade.php',
<ide> '<div> | 1 |
Go | Go | fix potential deadlock in getsvcrecords() | 92e20b70e648b666bc82f4eff448e6a11726eb5b | <ide><path>libnetwork/network.go
<ide> func (n *network) getSvcRecords(ep *endpoint) []etchosts.Record {
<ide> continue
<ide> }
<ide> if len(ip) == 0 {
<del> log.Warnf("Found empty list of IP addresses for service %s on network %s (%s)", h, n.Name(), n.ID())
<add> log.Warnf("Found empty list of IP addresses for service %s on network %s (%s)", h, n.name, n.id)
<ide> continue
<ide> }
<ide> recs = append(recs, etchosts.Record{ | 1 |
Ruby | Ruby | allow optional output path in std_go_args | 3f357861aa2dde712b02f2e2a05e30aefc0c4842 | <ide><path>Library/Homebrew/formula.rb
<ide> def std_cmake_args(install_prefix: prefix, install_libdir: "lib", find_framework
<ide> end
<ide>
<ide> # Standard parameters for Go builds.
<del> sig { params(ldflags: T.nilable(String)).returns(T::Array[String]) }
<del> def std_go_args(ldflags: nil)
<del> args = ["-trimpath", "-o=#{bin/name}"]
<add> sig { params(output: T.any(String, Pathname), ldflags: T.nilable(String)).returns(T::Array[String]) }
<add> def std_go_args(output: bin/name, ldflags: nil)
<add> args = ["-trimpath", "-o=#{output}"]
<ide> args += ["-ldflags=#{ldflags}"] if ldflags
<ide> args
<ide> end | 1 |
Javascript | Javascript | adjust specs for the changed event shape | 67a8ba2a046f6f6abe40589e554b1e746e6ba69c | <ide><path>spec/path-watcher-spec.js
<ide> describe('watchPath', function () {
<ide> return new Promise(resolve => {
<ide> const sub = watcher.onDidChange(events => {
<ide> for (const event of events) {
<del> if (waiting.delete(event.oldPath)) {
<add> if (waiting.delete(event.path)) {
<ide> relevantEvents.push(event)
<ide> }
<ide> } | 1 |
Ruby | Ruby | remove unused require | 47200f502d4ae477545b3d7583f05db2df09c5ba | <ide><path>actionpack/lib/action_controller/metal/rendering.rb
<ide> # frozen_string_literal: true
<ide>
<del>require "active_support/core_ext/string/filters"
<del>
<ide> module ActionController
<ide> module Rendering
<ide> extend ActiveSupport::Concern | 1 |
Text | Text | fix typo in ignoring-typescript-errors.md | 04d5bbcc50fb532de1d0cff3f04791fcd52b309c | <ide><path>docs/api-reference/next.config.js/ignoring-typescript-errors.md
<ide> If you'd like Next.js to dangerously produce production code even when your appl
<ide>
<ide> > Be sure you are running type checks as part of your build or deploy process, otherwise this can be very dangerous.
<ide>
<del>Open `next.config.js` and enable the `ignoreDevErrors` option in the `typescript` config:
<add>Open `next.config.js` and enable the `ignoreBuildErrors` option in the `typescript` config:
<ide>
<ide> ```js
<ide> module.exports = { | 1 |
Ruby | Ruby | move linkedkegs migration | 8f1ae3b28b0a12fe4a9d905dd4c41873d1674377 | <ide><path>Library/Homebrew/brew.rb
<ide> def require?(path)
<ide> # `Homebrew.help` never returns, except for external/unknown commands.
<ide> end
<ide>
<add> # Migrate LinkedKegs/PinnedKegs if update didn't already do so
<add> migrate_legacy_keg_symlinks_if_necessary
<add>
<ide> # Uninstall old brew-cask if it's still around; we just use the tap now.
<ide> if cmd == "cask" && (HOMEBREW_CELLAR/"brew-cask").exist?
<ide> system(HOMEBREW_BREW_FILE, "uninstall", "--force", "brew-cask")
<ide><path>Library/Homebrew/cmd/update-report.rb
<ide> require "formulary"
<ide> require "descriptions"
<ide> require "cleanup"
<add>require "utils"
<ide>
<ide> module Homebrew
<ide> def update_preinstall_header
<ide> def migrate_legacy_cache_if_necessary
<ide> end
<ide> end
<ide>
<del> def migrate_legacy_keg_symlinks_if_necessary
<del> legacy_linked_kegs = HOMEBREW_LIBRARY/"LinkedKegs"
<del> return unless legacy_linked_kegs.directory?
<del>
<del> legacy_linked_kegs.children.each do |f|
<del> keg = Keg.new(f.realpath)
<del> keg.unlink
<del> keg.link
<del> end
<del> FileUtils.rm_rf legacy_linked_kegs
<del>
<del> legacy_pinned_kegs = HOMEBREW_LIBRARY/"PinnedKegs"
<del> return unless legacy_pinned_kegs.directory?
<del>
<del> legacy_pinned_kegs.children.each do |f|
<del> pin_version = Keg.new(f.realpath).version
<del> formula = Formulary.factory(f.basename.to_s)
<del> pin = FormulaPin.new(formula)
<del> pin.unpin
<del> pin.pin_at(pin_version)
<del> end
<del> FileUtils.rm_rf legacy_pinned_kegs
<del> end
<del>
<ide> def link_completions_and_docs
<ide> return if HOMEBREW_PREFIX.to_s == HOMEBREW_REPOSITORY.to_s
<ide> command = "brew update"
<ide><path>Library/Homebrew/config.rb
<ide> HOMEBREW_SHIMS_PATH = HOMEBREW_LIBRARY/"Homebrew/shims"
<ide>
<ide> # Where we store symlinks to currently linked kegs
<del>HOMEBREW_LINKED_KEGS = if (HOMEBREW_LIBRARY/"LinkedKegs").exist?
<del> HOMEBREW_LIBRARY/"LinkedKegs"
<del>else
<del> HOMEBREW_PREFIX/"var/homebrew/linked"
<del>end
<add>HOMEBREW_LINKED_KEGS = HOMEBREW_PREFIX/"var/homebrew/linked"
<ide>
<ide> # Where we store symlinks to currently version-pinned kegs
<del>HOMEBREW_PINNED_KEGS = if (HOMEBREW_LIBRARY/"PinnedKegs").exist?
<del> HOMEBREW_LIBRARY/"PinnedKegs"
<del>else
<del> HOMEBREW_PREFIX/"var/homebrew/pinned"
<del>end
<add>HOMEBREW_PINNED_KEGS = HOMEBREW_PREFIX/"var/homebrew/pinned"
<ide>
<ide> # Where we store lock files
<ide> HOMEBREW_LOCK_DIR = HOMEBREW_PREFIX/"var/homebrew/locks"
<ide><path>Library/Homebrew/utils.rb
<ide> def link_src_dst_dirs(src_dir, dst_dir, command, link_dir: false)
<ide> def link_path_manpages(path, command)
<ide> link_src_dst_dirs(path/"man", HOMEBREW_PREFIX/"share/man", command)
<ide> end
<add>
<add>def migrate_legacy_keg_symlinks_if_necessary
<add> legacy_linked_kegs = HOMEBREW_LIBRARY/"LinkedKegs"
<add> return unless legacy_linked_kegs.directory?
<add>
<add> legacy_linked_kegs.children.each do |f|
<add> keg = Keg.new(f.realpath)
<add> keg.unlink
<add> keg.link
<add> end
<add> FileUtils.rm_rf legacy_linked_kegs
<add>
<add> legacy_pinned_kegs = HOMEBREW_LIBRARY/"PinnedKegs"
<add> return unless legacy_pinned_kegs.directory?
<add>
<add> legacy_pinned_kegs.children.each do |f|
<add> pin_version = Keg.new(f.realpath).version
<add> formula = Formulary.factory(f.basename.to_s)
<add> pin = FormulaPin.new(formula)
<add> pin.unpin
<add> pin.pin_at(pin_version)
<add> end
<add> FileUtils.rm_rf legacy_pinned_kegs
<add>end | 4 |
Ruby | Ruby | enable more deprecations | 2d18ba586b3250062cd58c8f5af81fc30a35bb5f | <ide><path>Library/Homebrew/cask/lib/hbc/dsl.rb
<ide> def sha256(arg = nil)
<ide> end
<ide>
<ide> def license(*)
<del> # TODO: Uncomment after `license` has been
<del> # removed from all official taps.
<del> # odeprecated "Hbc::DSL#license"
<add> odeprecated "Hbc::DSL#license"
<ide> end
<ide>
<ide> # depends_on uses a load method so that multiple stanzas can be merged
<ide><path>Library/Homebrew/compat/software_spec.rb
<ide> class BottleSpecification
<ide> def revision(*args)
<del> # odeprecated "BottleSpecification.revision", "BottleSpecification.rebuild"
<add> odeprecated "BottleSpecification.revision", "BottleSpecification.rebuild"
<ide> rebuild(*args)
<ide> end
<ide> end
<ide><path>Library/Homebrew/compat/utils.rb
<del>def shell_profile
<del> # odeprecated "shell_profile", "Utils::Shell.profile"
<del> Utils::Shell.profile
<del>end
<del>
<ide> module Tty
<ide> module_function
<ide>
<ide><path>Library/Homebrew/formula.rb
<ide> def cxxstdlib_check(check_type)
<ide> # version '4.8.1'
<ide> # end</pre>
<ide> def fails_with(compiler, &block)
<del> # odeprecated "fails_with :llvm" if compiler == :llvm
<add> odeprecated "fails_with :llvm" if compiler == :llvm
<ide> specs.each { |spec| spec.fails_with(compiler, &block) }
<ide> end
<ide>
<ide><path>Library/Homebrew/software_spec.rb
<ide> def patch(strip = :p1, src = nil, &block)
<ide> end
<ide>
<ide> def fails_with(compiler, &block)
<del> # odeprecated "fails_with :llvm" if compiler == :llvm
<add> odeprecated "fails_with :llvm" if compiler == :llvm
<ide> compiler_failures << CompilerFailure.create(compiler, &block)
<ide> end
<ide>
<ide><path>Library/Homebrew/utils.rb
<ide> def with_env(hash)
<ide> ENV.update(old_values)
<ide> end
<ide> end
<add>
<add>def shell_profile
<add> Utils::Shell.profile
<add>end | 6 |
Python | Python | ensure linspace works on object input | b3fdef08b5c586fff50fdabb0967e53ccaaab3c4 | <ide><path>numpy/core/function_base.py
<ide>
<ide> from . import numeric as _nx
<ide> from .numeric import (result_type, NaN, shares_memory, MAY_SHARE_BOUNDS,
<del> TooHardError, asanyarray)
<add> TooHardError, asanyarray, ndim)
<ide> from numpy.core.multiarray import add_docstring
<ide> from numpy.core import overrides
<ide>
<ide> def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None,
<ide> dtype = dt
<ide>
<ide> delta = stop - start
<del> y = _nx.arange(0, num, dtype=dt).reshape((-1,) + (1,) * delta.ndim)
<add> y = _nx.arange(0, num, dtype=dt).reshape((-1,) + (1,) * ndim(delta))
<ide> # In-place multiplication y *= delta/div is faster, but prevents the multiplicant
<ide> # from overriding what class is produced, and thus prevents, e.g. use of Quantities,
<ide> # see gh-7142. Hence, we multiply in place only for standard scalar types.
<ide><path>numpy/core/tests/test_function_base.py
<ide> def test_retstep(self):
<ide> assert_(isinstance(y, tuple) and len(y) == 2 and
<ide> len(y[0]) == num and isnan(y[1]),
<ide> 'num={0}, endpoint={1}'.format(num, ept))
<add>
<add> def test_object(self):
<add> start = array(1, dtype='O')
<add> stop = array(2, dtype='O')
<add> y = linspace(start, stop, 3)
<add> assert_array_equal(y, array([1., 1.5, 2.])) | 2 |
Javascript | Javascript | remove flowfixme on ref | 0939b938b2a9beee74f5c44cdef25e0a227efe0d | <ide><path>Libraries/Lists/VirtualizedSectionList.js
<ide> class VirtualizedSectionList<
<ide> index += this.props.getItemCount(this.props.sections[i].data) + 2;
<ide> }
<ide> let viewOffset = params.viewOffset || 0;
<add> if (this._listRef == null) {
<add> return;
<add> }
<ide> if (params.itemIndex > 0 && this.props.stickySectionHeadersEnabled) {
<del> // $FlowFixMe Cannot access private property
<add> // $FlowFixMe[prop-missing] Cannot access private property
<ide> const frame = this._listRef._getFrameMetricsApprox(
<ide> index - params.itemIndex,
<ide> );
<ide> class VirtualizedSectionList<
<ide> this._listRef.scrollToIndex(toIndexParams);
<ide> }
<ide>
<del> getListRef(): VirtualizedList {
<add> getListRef(): ?React.ElementRef<typeof VirtualizedList> {
<ide> return this._listRef;
<ide> }
<ide>
<ide> class VirtualizedSectionList<
<ide> }
<ide>
<ide> _cellRefs = {};
<del> _listRef: VirtualizedList;
<add> _listRef: ?React.ElementRef<typeof VirtualizedList>;
<ide> _captureRef = ref => {
<del> /* $FlowFixMe(>=0.53.0 site=react_native_fb,react_native_oss) This comment
<del> * suppresses an error when upgrading Flow's support for React. To see the
<del> * error delete this comment and run Flow. */
<ide> this._listRef = ref;
<ide> };
<ide> } | 1 |
Ruby | Ruby | replace x.sort_by!.select! with x.select!.sort_by! | 8ee785a17fa0dab88762c2866507bb33760c9f7a | <ide><path>actionpack/lib/action_dispatch/journey/router.rb
<ide> def find_routes req
<ide> routes.concat get_routes_as_head(routes)
<ide> end
<ide>
<del> routes.sort_by!(&:precedence).select! { |r| r.matches?(req) }
<add> routes.select! { |r| r.matches?(req) }
<add> routes.sort_by!(&:precedence)
<ide>
<ide> routes.map! { |r|
<ide> match_data = r.path.match(req.path_info) | 1 |
PHP | PHP | fix touchowners() on many to many relationship | deebda1e4a02fe901b83bacaf35a53da9606c1e1 | <ide><path>src/Illuminate/Database/Eloquent/Model.php
<ide> public function touchOwners()
<ide> {
<ide> $this->$relation()->touch();
<ide>
<del> if ( ! is_null($this->$relation))
<add> if ( ! is_null($this->$relation) && $this->$relation instanceof Model)
<ide> {
<ide> $this->$relation->touchOwners();
<ide> }
<add> elseif ( ! is_null($this->$relation) && $this->$relation instanceof Collection)
<add> {
<add> $this->$relation->each(function (Model $relation)
<add> {
<add> $relation->touchOwners();
<add> });
<add> }
<ide> }
<ide> }
<ide> | 1 |
PHP | PHP | withouteventdispatcher() method | 645e622a519f5bc8a52ddabf1cd6507fd5d57d39 | <ide><path>src/Illuminate/Database/Eloquent/Concerns/HasEvents.php
<ide> public static function unsetEventDispatcher()
<ide> {
<ide> static::$dispatcher = null;
<ide> }
<add>
<add> /**
<add> * Execute a callback without the event dispatcher.
<add> *
<add> * @param callable $callback
<add> * @return mixed
<add> */
<add> public static function withoutEventDispatcher(callable $callback)
<add> {
<add> $dispatcher = static::getEventDispatcher();
<add>
<add> static::unsetEventDispatcher();
<add>
<add> try {
<add> $result = $callback();
<add> } finally {
<add> if ($dispatcher) {
<add> static::setEventDispatcher($dispatcher);
<add> }
<add> }
<add>
<add> return $result;
<add> }
<ide> }
<ide><path>tests/Database/DatabaseEloquentModelTest.php
<ide> public function testModelObserversCanBeAttachedToModelsThroughCallingObserveMeth
<ide> EloquentModelStub::flushEventListeners();
<ide> }
<ide>
<add> public function testWithoutEventDispatcher()
<add> {
<add> EloquentModelSaveStub::setEventDispatcher($events = m::mock(Dispatcher::class));
<add> $events->shouldReceive('listen')->once()->with('eloquent.creating: Illuminate\Tests\Database\EloquentModelSaveStub', EloquentTestObserverStub::class.'@creating');
<add> $events->shouldReceive('listen')->once()->with('eloquent.saved: Illuminate\Tests\Database\EloquentModelSaveStub', EloquentTestObserverStub::class.'@saved');
<add> $events->shouldNotReceive('until');
<add> $events->shouldNotReceive('dispatch');
<add> $events->shouldReceive('forget');
<add> EloquentModelSaveStub::observe(EloquentTestObserverStub::class);
<add>
<add> $model = EloquentModelSaveStub::withoutEventDispatcher(function () {
<add> $model = new EloquentModelSaveStub;
<add> $model->save();
<add> return $model;
<add> });
<add>
<add> $model->withoutEventDispatcher(function () use ($model) {
<add> $model->name = 'Taylor';
<add> $model->save();
<add> });
<add>
<add> EloquentModelSaveStub::flushEventListeners();
<add> }
<add>
<ide> public function testSetObservableEvents()
<ide> {
<ide> $class = new EloquentModelStub;
<ide> class EloquentModelSaveStub extends Model
<ide>
<ide> public function save(array $options = [])
<ide> {
<add> if ($this->fireModelEvent('saving') === false) {
<add> return false;
<add> }
<add>
<ide> $_SERVER['__eloquent.saved'] = true;
<add>
<add> $this->fireModelEvent('saved', false);
<ide> }
<ide>
<ide> public function setIncrementing($value) | 2 |
Java | Java | fix behavior of clientresponse#bodyto** with void | 126ac849e5592f65d742d1f23bf891e1a115af01 | <ide><path>spring-test/src/main/java/org/springframework/mock/http/client/reactive/MockClientHttpResponse.java
<ide> public class MockClientHttpResponse implements ClientHttpResponse {
<ide>
<ide> private final DataBufferFactory bufferFactory = new DefaultDataBufferFactory();
<ide>
<del> private boolean closed = false;
<del>
<ide>
<ide> public MockClientHttpResponse(HttpStatus status) {
<ide> Assert.notNull(status, "HttpStatus is required");
<ide> private DataBuffer toDataBuffer(String body, Charset charset) {
<ide>
<ide> @Override
<ide> public Flux<DataBuffer> getBody() {
<del> if (this.closed) {
<del> return Flux.error(new IllegalStateException("Connection has been closed."));
<del> }
<ide> return this.body;
<ide> }
<ide>
<del> @Override
<del> public void close() {
<del> this.closed = true;
<del> }
<del>
<del> public boolean isClosed() {
<del> return this.closed;
<del> }
<del>
<ide> /**
<ide> * Return the response body aggregated and converted to a String using the
<ide> * charset of the Content-Type response or otherwise as "UTF-8".
<ide><path>spring-web/src/main/java/org/springframework/http/client/reactive/ClientHttpResponse.java
<ide>
<ide> package org.springframework.http.client.reactive;
<ide>
<del>import java.io.Closeable;
<del>
<ide> import org.springframework.http.HttpStatus;
<ide> import org.springframework.http.ReactiveHttpInputMessage;
<ide> import org.springframework.http.ResponseCookie;
<ide> * @author Brian Clozel
<ide> * @since 5.0
<ide> */
<del>public interface ClientHttpResponse extends ReactiveHttpInputMessage, Closeable {
<add>public interface ClientHttpResponse extends ReactiveHttpInputMessage {
<ide>
<ide> /**
<ide> * Return the HTTP status as an {@link HttpStatus} enum value.
<ide> public interface ClientHttpResponse extends ReactiveHttpInputMessage, Closeable
<ide> */
<ide> MultiValueMap<String, ResponseCookie> getCookies();
<ide>
<del> /**
<del> * Close this response and the underlying HTTP connection.
<del> * <p>This non-blocking method has to be called if its body isn't going
<del> * to be consumed. Not doing so might result in HTTP connection pool
<del> * inconsistencies or memory leaks.
<del> * <p>This shouldn't be called if the response body is read,
<del> * because it would prevent connections to be reused and cancel
<del> * the benefits of using a connection pooling.
<del> */
<del> @Override
<del> void close();
<del>
<ide> }
<ide><path>spring-web/src/main/java/org/springframework/http/client/reactive/ClientHttpResponseDecorator.java
<ide> public Flux<DataBuffer> getBody() {
<ide> return this.delegate.getBody();
<ide> }
<ide>
<del> @Override
<del> public void close() {
<del> this.delegate.close();
<del> }
<del>
<ide> @Override
<ide> public String toString() {
<ide> return getClass().getSimpleName() + " [delegate=" + getDelegate() + "]";
<ide><path>spring-web/src/main/java/org/springframework/http/client/reactive/ReactorClientHttpResponse.java
<ide> public MultiValueMap<String, ResponseCookie> getCookies() {
<ide> return CollectionUtils.unmodifiableMultiValueMap(result);
<ide> }
<ide>
<del> @Override
<del> public void close() {
<del> this.response.dispose();
<del> }
<del>
<ide> @Override
<ide> public String toString() {
<ide> return "ReactorClientHttpResponse{" +
<ide><path>spring-web/src/test/java/org/springframework/mock/http/client/reactive/test/MockClientHttpResponse.java
<ide> public class MockClientHttpResponse implements ClientHttpResponse {
<ide>
<ide> private final DataBufferFactory bufferFactory = new DefaultDataBufferFactory();
<ide>
<del> private boolean closed = false;
<ide>
<ide> public MockClientHttpResponse(HttpStatus status) {
<ide> Assert.notNull(status, "HttpStatus is required");
<ide> private DataBuffer toDataBuffer(String body, Charset charset) {
<ide>
<ide> @Override
<ide> public Flux<DataBuffer> getBody() {
<del> if (this.closed) {
<del> return Flux.error(new IllegalStateException("Connection has been closed."));
<del> }
<ide> return this.body;
<ide> }
<ide>
<del> @Override
<del> public void close() {
<del> this.closed = true;
<del> }
<del>
<del> public boolean isClosed() {
<del> return this.closed;
<del> }
<del>
<ide> /**
<ide> * Return the response body aggregated and converted to a String using the
<ide> * charset of the Content-Type response or otherwise as "UTF-8".
<ide><path>spring-webflux/src/main/java/org/springframework/web/reactive/function/client/ClientResponse.java
<ide>
<ide> package org.springframework.web.reactive.function.client;
<ide>
<del>import java.io.Closeable;
<ide> import java.util.List;
<ide> import java.util.Optional;
<ide> import java.util.OptionalLong;
<ide> * @author Arjen Poutsma
<ide> * @since 5.0
<ide> */
<del>public interface ClientResponse extends Closeable {
<add>public interface ClientResponse {
<ide>
<ide> /**
<ide> * Return the status code of this response.
<ide> public interface ClientResponse extends Closeable {
<ide> */
<ide> <T> Mono<ResponseEntity<List<T>>> toEntityList(ParameterizedTypeReference<T> typeReference);
<ide>
<del> /**
<del> * Close this response and the underlying HTTP connection.
<del> * <p>This non-blocking method has to be called if its body isn't going
<del> * to be consumed. Not doing so might result in HTTP connection pool
<del> * inconsistencies or memory leaks.
<del> * <p>This shouldn't be called if the response body is read,
<del> * because it would prevent connections to be reused and cancel
<del> * the benefits of using a connection pooling.
<del> */
<del> @Override
<del> void close();
<del>
<ide>
<ide> /**
<ide> * Represents the headers of the HTTP response.
<ide><path>spring-webflux/src/main/java/org/springframework/web/reactive/function/client/DefaultClientResponse.java
<ide> import reactor.core.publisher.Mono;
<ide>
<ide> import org.springframework.core.ParameterizedTypeReference;
<add>import org.springframework.core.io.buffer.DataBufferUtils;
<ide> import org.springframework.http.HttpHeaders;
<ide> import org.springframework.http.HttpStatus;
<ide> import org.springframework.http.MediaType;
<ide> public Map<String, Object> hints() {
<ide>
<ide> @Override
<ide> public <T> Mono<T> bodyToMono(Class<? extends T> elementClass) {
<del> return body(BodyExtractors.toMono(elementClass));
<add> if (Void.class.isAssignableFrom(elementClass)) {
<add> return consumeAndCancel();
<add> }
<add> else {
<add> return body(BodyExtractors.toMono(elementClass));
<add> }
<add> }
<add>
<add> @SuppressWarnings("unchecked")
<add> private <T> Mono<T> consumeAndCancel() {
<add> return (Mono<T>) this.response.getBody()
<add> .map(buffer -> {
<add> DataBufferUtils.release(buffer);
<add> throw new ReadCancellationException();
<add> })
<add> .onErrorResume(ReadCancellationException.class, ex -> Mono.empty())
<add> .then();
<ide> }
<ide>
<ide> @Override
<ide> public <T> Mono<T> bodyToMono(ParameterizedTypeReference<T> typeReference) {
<del> return body(BodyExtractors.toMono(typeReference));
<add> if (Void.class.isAssignableFrom(typeReference.getType().getClass())) {
<add> return consumeAndCancel();
<add> }
<add> else {
<add> return body(BodyExtractors.toMono(typeReference));
<add> }
<ide> }
<ide>
<ide> @Override
<ide> public <T> Flux<T> bodyToFlux(Class<? extends T> elementClass) {
<del> return body(BodyExtractors.toFlux(elementClass));
<add> if (Void.class.isAssignableFrom(elementClass)) {
<add> return Flux.from(consumeAndCancel());
<add> }
<add> else {
<add> return body(BodyExtractors.toFlux(elementClass));
<add> }
<ide> }
<ide>
<ide> @Override
<ide> public <T> Flux<T> bodyToFlux(ParameterizedTypeReference<T> typeReference) {
<del> return body(BodyExtractors.toFlux(typeReference));
<add> if (Void.class.isAssignableFrom(typeReference.getType().getClass())) {
<add> return Flux.from(consumeAndCancel());
<add> }
<add> else {
<add> return body(BodyExtractors.toFlux(typeReference));
<add> }
<ide> }
<ide>
<ide> @Override
<ide> public <T> Mono<ResponseEntity<T>> toEntity(Class<T> bodyType) {
<del> return toEntityInternal(bodyToMono(bodyType));
<add> if (Void.class.isAssignableFrom(bodyType)) {
<add> return toEntityInternal(consumeAndCancel());
<add> }
<add> else {
<add> return toEntityInternal(bodyToMono(bodyType));
<add> }
<ide> }
<ide>
<ide> @Override
<ide> public <T> Mono<ResponseEntity<T>> toEntity(ParameterizedTypeReference<T> typeReference) {
<del> return toEntityInternal(bodyToMono(typeReference));
<add> if (Void.class.isAssignableFrom(typeReference.getType().getClass())) {
<add> return toEntityInternal(consumeAndCancel());
<add> }
<add> else {
<add> return toEntityInternal(bodyToMono(typeReference));
<add> }
<ide> }
<ide>
<ide> private <T> Mono<ResponseEntity<T>> toEntityInternal(Mono<T> bodyMono) {
<ide> private <T> Mono<ResponseEntity<List<T>>> toEntityListInternal(Flux<T> bodyFlux)
<ide> .map(body -> new ResponseEntity<>(body, headers, statusCode));
<ide> }
<ide>
<del> @Override
<del> public void close() {
<del> this.response.close();
<del> }
<ide>
<ide> private class DefaultHeaders implements Headers {
<ide>
<ide> private OptionalLong toOptionalLong(long value) {
<ide> }
<ide>
<ide> }
<add>
<add> @SuppressWarnings("serial")
<add> private class ReadCancellationException extends RuntimeException {
<add> }
<ide> }
<ide><path>spring-webflux/src/main/java/org/springframework/web/reactive/function/client/WebClient.java
<ide> interface Builder {
<ide> * .exchange()
<ide> * .flatMapMany(response -> response.bodyToFlux(Pojo.class));
<ide> * </pre>
<del> * <p>If the response body is not consumed with {@code bodyTo*}
<del> * or {@code toEntity*} methods, it is your responsibility
<del> * to release the HTTP resources with {@link ClientResponse#close()}.
<del> * <pre>
<del> * Mono<HttpStatus> mono = client.get().uri("/")
<del> * .exchange()
<del> * .map(response -> {
<del> * response.close();
<del> * return response.statusCode();
<del> * });
<del> * </pre>
<add> * <p>The response body should always be consumed with {@code bodyTo*}
<add> * or {@code toEntity*} methods; if you do not care about the body,
<add> * you can use {@code bodyToMono(Void.class)}.
<add> * <p>Not consuming the response body might lead to HTTP connection pool
<add> * inconsistencies or memory leaks.
<ide> * @return a {@code Mono} with the response
<ide> * @see #retrieve()
<ide> */
<ide> interface Builder {
<ide> * .retrieve()
<ide> * .bodyToMono(Pojo.class);
<ide> * </pre>
<del> * <p>Since this method reads the response body,
<del> * {@link ClientResponse#close()} should not be called.
<ide> * @return spec with options for extracting the response body
<ide> */
<ide> ResponseSpec retrieve();
<ide><path>spring-webflux/src/test/java/org/springframework/web/reactive/function/client/DefaultClientResponseTests.java
<ide> import org.junit.Test;
<ide> import reactor.core.publisher.Flux;
<ide> import reactor.core.publisher.Mono;
<add>import reactor.test.StepVerifier;
<add>import reactor.test.publisher.TestPublisher;
<ide>
<ide> import org.springframework.core.ParameterizedTypeReference;
<ide> import org.springframework.core.codec.StringDecoder;
<ide> import org.springframework.util.LinkedMultiValueMap;
<ide> import org.springframework.util.MultiValueMap;
<ide>
<del>import static org.junit.Assert.*;
<del>import static org.mockito.Mockito.*;
<add>import static org.junit.Assert.assertEquals;
<add>import static org.junit.Assert.assertSame;
<add>import static org.mockito.Mockito.mock;
<add>import static org.mockito.Mockito.when;
<ide> import static org.springframework.web.reactive.function.BodyExtractors.toMono;
<ide>
<ide> /**
<ide> public void bodyToFluxTypeReference() throws Exception {
<ide> when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders);
<ide>
<ide> Flux<String> resultFlux =
<del> defaultClientResponse.bodyToFlux(new ParameterizedTypeReference<String>() {});
<add> defaultClientResponse.bodyToFlux(new ParameterizedTypeReference<String>() {
<add> });
<ide> Mono<List<String>> result = resultFlux.collectList();
<ide> assertEquals(Collections.singletonList("foo"), result.block());
<ide> }
<ide> public void toEntityTypeReference() throws Exception {
<ide> when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders);
<ide>
<ide> ResponseEntity<String> result = defaultClientResponse.toEntity(
<del> new ParameterizedTypeReference<String>() {}).block();
<add> new ParameterizedTypeReference<String>() {
<add> }).block();
<ide> assertEquals("foo", result.getBody());
<ide> assertEquals(HttpStatus.OK, result.getStatusCode());
<ide> assertEquals(MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
<ide> public void toEntityListTypeReference() throws Exception {
<ide> when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders);
<ide>
<ide> ResponseEntity<List<String>> result = defaultClientResponse.toEntityList(
<del> new ParameterizedTypeReference<String>() {}).block();
<add> new ParameterizedTypeReference<String>() {
<add> }).block();
<ide> assertEquals(Collections.singletonList("foo"), result.getBody());
<ide> assertEquals(HttpStatus.OK, result.getStatusCode());
<ide> assertEquals(MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
<ide> }
<ide>
<add> @Test
<add> public void toMonoVoid() throws Exception {
<add> TestPublisher<DataBuffer> body = TestPublisher.create();
<add>
<add> HttpHeaders httpHeaders = new HttpHeaders();
<add> httpHeaders.setContentType(MediaType.TEXT_PLAIN);
<add> when(mockResponse.getHeaders()).thenReturn(httpHeaders);
<add> when(mockResponse.getStatusCode()).thenReturn(HttpStatus.OK);
<add> when(mockResponse.getBody()).thenReturn(body.flux());
<add>
<add> List<HttpMessageReader<?>> messageReaders = Collections
<add> .singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(true)));
<add> when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders);
<add>
<add> StepVerifier.create(defaultClientResponse.bodyToMono(Void.class))
<add> .then(() -> {
<add> body.assertWasSubscribed();
<add> body.complete();
<add> })
<add> .verifyComplete();
<add> }
<add>
<add> @Test
<add> public void toMonoVoidNonEmptyBody() throws Exception {
<add> DefaultDataBufferFactory factory = new DefaultDataBufferFactory();
<add> DefaultDataBuffer dataBuffer =
<add> factory.wrap(ByteBuffer.wrap("foo".getBytes(StandardCharsets.UTF_8)));
<add> TestPublisher<DataBuffer> body = TestPublisher.create();
<add>
<add> HttpHeaders httpHeaders = new HttpHeaders();
<add> httpHeaders.setContentType(MediaType.TEXT_PLAIN);
<add> when(mockResponse.getHeaders()).thenReturn(httpHeaders);
<add> when(mockResponse.getStatusCode()).thenReturn(HttpStatus.OK);
<add> when(mockResponse.getBody()).thenReturn(body.flux());
<ide>
<add> List<HttpMessageReader<?>> messageReaders = Collections
<add> .singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(true)));
<add> when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders);
<add>
<add> StepVerifier.create(defaultClientResponse.bodyToMono(Void.class))
<add> .then(() -> {
<add> body.assertWasSubscribed();
<add> body.emit(dataBuffer);
<add> })
<add> .verifyComplete();
<ide>
<add> body.assertCancelled();
<add> }
<ide>
<ide> }
<ide><path>spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientIntegrationTests.java
<ide> public void shouldApplyErrorHandlingFilter() throws Exception {
<ide>
<ide> @Test
<ide> public void shouldReceiveEmptyResponse() throws Exception {
<del> prepareResponse(response -> response.setHeader("Content-Length", "0"));
<add> prepareResponse(response -> response.setHeader("Content-Length", "0").setBody(""));
<ide>
<del> Mono<ClientResponse> result = this.webClient.get()
<add> Mono<ResponseEntity<Void>> result = this.webClient.get()
<ide> .uri("/noContent")
<del> .exchange();
<add> .exchange()
<add> .flatMap(response -> response.toEntity(Void.class));
<ide>
<ide> StepVerifier.create(result).assertNext(r -> {
<del> assertTrue(r.statusCode().is2xxSuccessful());
<del> StepVerifier.create(r.bodyToMono(Void.class)).verifyComplete();
<add> assertTrue(r.getStatusCode().is2xxSuccessful());
<ide> }).verifyComplete();
<ide> }
<ide>
<ide><path>spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientMockTests.java
<del>package org.springframework.web.reactive.function.client;
<del>
<del>import org.junit.Before;
<del>import org.junit.Test;
<del>import reactor.core.publisher.Mono;
<del>import reactor.test.StepVerifier;
<del>
<del>import org.springframework.http.HttpHeaders;
<del>import org.springframework.http.HttpStatus;
<del>import org.springframework.http.client.reactive.ClientHttpConnector;
<del>import org.springframework.mock.http.client.reactive.test.MockClientHttpResponse;
<del>
<del>import static org.junit.Assert.assertFalse;
<del>import static org.mockito.ArgumentMatchers.any;
<del>import static org.mockito.BDDMockito.given;
<del>import static org.mockito.Mockito.mock;
<del>
<del>/**
<del> * Mock tests using a {@link ExchangeFunction} through {@link WebClient}.
<del> *
<del> * @author Brian Clozel
<del> */
<del>public class WebClientMockTests {
<del>
<del> private MockClientHttpResponse response;
<del>
<del> private ClientHttpConnector mockConnector;
<del>
<del> private WebClient webClient;
<del>
<del> @Before
<del> public void setUp() throws Exception {
<del> this.mockConnector = mock(ClientHttpConnector.class);
<del> this.webClient = WebClient.builder().clientConnector(this.mockConnector).build();
<del> this.response = new MockClientHttpResponse(HttpStatus.OK);
<del> this.response.setBody("example");
<del>
<del> given(this.mockConnector.connect(any(), any(), any())).willReturn(Mono.just(this.response));
<del> }
<del>
<del> @Test
<del> public void shouldDisposeResponseManually() {
<del> Mono<HttpHeaders> headers = this.webClient
<del> .get().uri("/test")
<del> .exchange()
<del> .map(response -> response.headers().asHttpHeaders());
<del> StepVerifier.create(headers)
<del> .expectNextCount(1)
<del> .verifyComplete();
<del> assertFalse(this.response.isClosed());
<del> }
<del>
<del>} | 11 |
Javascript | Javascript | add test for overriding attr value in init | 04e0251493099503a3602303c66ff23543ca213c | <ide><path>packages/ember-htmlbars/tests/integration/component_invocation_test.js
<ide> QUnit.test('non-block with properties on attrs and component class', function()
<ide> equal(jQuery('#qunit-fixture').text(), 'In layout - someProp: something here');
<ide> });
<ide>
<add>QUnit.test('non-block with properties on overridden in init', function() {
<add> owner.register('component:non-block', Component.extend({
<add> someProp: null,
<add>
<add> init() {
<add> this._super(...arguments);
<add> this.someProp = 'value set in init';
<add> }
<add> }));
<add> owner.register('template:components/non-block', compile('In layout - someProp: {{someProp}}'));
<add>
<add> view = EmberView.extend({
<add> [OWNER]: owner,
<add> template: compile('{{non-block someProp="something passed when invoked"}}')
<add> }).create();
<add>
<add> runAppend(view);
<add>
<add> equal(view.$().text(), 'In layout - someProp: value set in init');
<add>});
<add>
<ide> QUnit.test('lookup of component takes priority over property', function() {
<ide> expect(1);
<ide> | 1 |
PHP | PHP | fix selected columns on hasmanythrough | 078697196e7f7f6c3315c8657ec2fb2310c4d423 | <ide><path>src/Illuminate/Database/Eloquent/Relations/HasManyThrough.php
<ide> public function get($columns = array('*'))
<ide> // First we'll add the proper select columns onto the query so it is run with
<ide> // the proper columns. Then, we will get the results and hydrate out pivot
<ide> // models with the result of those columns as a separate model relation.
<add> $columns = $this->query->getQuery()->columns ? array() : $columns;
<add>
<ide> $select = $this->getSelectColumns($columns);
<ide>
<ide> $models = $this->query->addSelect($select)->getModels();
<ide><path>tests/Database/DatabaseEloquentHasManyThroughTest.php
<ide> public function testModelsAreProperlyMatchedToParents()
<ide> }
<ide>
<ide>
<add> public function testAllColumnsAreSelectedByDefault()
<add> {
<add> $select = array('posts.*', 'users.country_id');
<add>
<add> $baseBuilder = m::mock('Illuminate\Database\Query\Builder');
<add>
<add> $relation = $this->getRelation();
<add> $relation->getRelated()->shouldReceive('newCollection')->once();
<add>
<add> $builder = $relation->getQuery();
<add> $builder->shouldReceive('getQuery')->andReturn($baseBuilder);
<add> $builder->shouldReceive('addSelect')->once()->with($select)->andReturn($builder);
<add> $builder->shouldReceive('getModels')->once()->andReturn(array());
<add>
<add> $relation->get();
<add> }
<add>
<add>
<add> public function testOnlyProperColumnsAreSelectedIfProvided()
<add> {
<add> $select = array('users.country_id');
<add>
<add> $baseBuilder = m::mock('Illuminate\Database\Query\Builder');
<add> $baseBuilder->columns = array('foo', 'bar');
<add>
<add> $relation = $this->getRelation();
<add> $relation->getRelated()->shouldReceive('newCollection')->once();
<add>
<add> $builder = $relation->getQuery();
<add> $builder->shouldReceive('getQuery')->andReturn($baseBuilder);
<add> $builder->shouldReceive('addSelect')->once()->with($select)->andReturn($builder);
<add> $builder->shouldReceive('getModels')->once()->andReturn(array());
<add>
<add> $relation->get();
<add> }
<add>
<add>
<ide> protected function getRelation()
<ide> {
<ide> $builder = m::mock('Illuminate\Database\Eloquent\Builder'); | 2 |
Javascript | Javascript | fix inconsistency between load and _findpath | 1b92214d097358040efb7d3ec5dff1736f364bc0 | <ide><path>lib/internal/modules/cjs/loader.js
<ide> function tryExtensions(p, exts, isMain) {
<ide> return false;
<ide> }
<ide>
<add>function readExtensions() {
<add> const exts = Object.keys(Module._extensions);
<add> for (var i = 0, j = 0; i < exts.length; ++i) {
<add> if (path.extname(exts[i]) === '')
<add> exts[j++] = exts[i];
<add> }
<add> exts.length = j;
<add> return exts;
<add>}
<add>
<ide> var warned = false;
<ide> Module._findPath = function(request, paths, isMain) {
<ide> if (path.isAbsolute(request)) {
<ide> Module._findPath = function(request, paths, isMain) {
<ide> if (!filename) {
<ide> // try it with each of the extensions
<ide> if (exts === undefined)
<del> exts = Object.keys(Module._extensions);
<add> exts = readExtensions();
<ide> filename = tryExtensions(basePath, exts, isMain);
<ide> }
<ide> }
<ide>
<ide> if (!filename && rc === 1) { // Directory.
<ide> // try it with each of the extensions at "index"
<ide> if (exts === undefined)
<del> exts = Object.keys(Module._extensions);
<add> exts = readExtensions();
<ide> filename = tryPackage(basePath, exts, isMain);
<ide> if (!filename) {
<ide> filename = tryExtensions(path.resolve(basePath, 'index'), exts, isMain);
<ide><path>test/known_issues/test-module-deleted-extensions.js
<del>'use strict';
<del>// Refs: https://github.com/nodejs/node/issues/4778
<del>const common = require('../common');
<del>const assert = require('assert');
<del>const fs = require('fs');
<del>const path = require('path');
<del>const tmpdir = require('../common/tmpdir');
<del>const file = path.join(tmpdir.path, 'test-extensions.foo.bar');
<del>
<del>tmpdir.refresh();
<del>fs.writeFileSync(file, '', 'utf8');
<del>require.extensions['.foo.bar'] = (module, path) => {};
<del>delete require.extensions['.foo.bar'];
<del>require.extensions['.bar'] = common.mustCall((module, path) => {
<del> assert.strictEqual(module.id, file);
<del> assert.strictEqual(path, file);
<del>});
<del>require(path.join(tmpdir.path, 'test-extensions'));
<ide><path>test/parallel/test-module-deleted-extensions.js
<add>'use strict';
<add>
<add>// Refs: https://github.com/nodejs/node/issues/4778
<add>
<add>const common = require('../common');
<add>const assert = require('assert');
<add>const fs = require('fs');
<add>const path = require('path');
<add>const tmpdir = require('../common/tmpdir');
<add>const file = path.join(tmpdir.path, 'test-extensions.foo.bar');
<add>
<add>tmpdir.refresh();
<add>fs.writeFileSync(file, '', 'utf8');
<add>
<add>{
<add> require.extensions['.bar'] = common.mustNotCall();
<add> require.extensions['.foo.bar'] = common.mustNotCall();
<add> const modulePath = path.join(tmpdir.path, 'test-extensions');
<add> assert.throws(
<add> () => require(modulePath),
<add> new Error(`Cannot find module '${modulePath}'`)
<add> );
<add>}
<add>
<add>{
<add> delete require.extensions['.bar'];
<add> require.extensions['.foo.bar'] = common.mustNotCall();
<add> const modulePath = path.join(tmpdir.path, 'test-extensions');
<add> assert.throws(
<add> () => require(modulePath),
<add> new Error(`Cannot find module '${modulePath}'`)
<add> );
<add> assert.throws(
<add> () => require(modulePath + '.foo'),
<add> new Error(`Cannot find module '${modulePath}.foo'`)
<add> );
<add>}
<add>
<add>{
<add> delete require.extensions['.bar'];
<add> delete require.extensions['.foo.bar'];
<add> const modulePath = path.join(tmpdir.path, 'test-extensions');
<add> assert.throws(
<add> () => require(modulePath),
<add> new Error(`Cannot find module '${modulePath}'`)
<add> );
<add>}
<add>
<add>{
<add> delete require.extensions['.foo.bar'];
<add> require.extensions['.bar'] = common.mustCall((module, path) => {
<add> assert.strictEqual(module.id, file);
<add> assert.strictEqual(path, file);
<add> });
<add>
<add> const modulePath = path.join(tmpdir.path, 'test-extensions.foo');
<add> require(modulePath);
<add>} | 3 |
PHP | PHP | fix return type | 773e2f20f8941f965407778345ecd4c3a33921b1 | <ide><path>src/Illuminate/Support/Collection.php
<ide> public function first(Closure $callback = null, $default = null)
<ide> /**
<ide> * Get a flattened array of the items in the collection.
<ide> *
<del> * @return array
<add> * @return \Illuminate\Support\Collection
<ide> */
<ide> public function flatten()
<ide> { | 1 |
Python | Python | fix docs of `metrics` parameter in `compile` | e6c11160ecd8e4e2c0bd8a10332c8bd494880aa8 | <ide><path>keras/engine/training.py
<ide> def compile(
<ide> strings 'accuracy' or 'acc', we convert this to one of
<ide> `tf.keras.metrics.BinaryAccuracy`,
<ide> `tf.keras.metrics.CategoricalAccuracy`,
<del> `tf.keras.metrics.SparseCategoricalAccuracy` based on the loss
<del> function used and the model output shape. We do a similar
<add> `tf.keras.metrics.SparseCategoricalAccuracy` based on the shapes
<add> of the targets and of the model output. We do a similar
<ide> conversion for the strings 'crossentropy' and 'ce' as well.
<ide> The metrics passed here are evaluated without sample weighting; if
<ide> you would like sample weighting to apply, you can specify your | 1 |
Python | Python | fix errorswithcodes().__class__ return value | a987e9e45d4084f30964a4cec9914ae6ed25a73c | <ide><path>spacy/errors.py
<ide> def add_codes(err_cls):
<ide>
<ide> class ErrorsWithCodes(object):
<ide> def __getattribute__(self, code):
<del> msg = getattr(err_cls, code)
<del> return "[{code}] {msg}".format(code=code, msg=msg)
<add> if not code.startswith('__'):
<add> msg = getattr(err_cls, code)
<add> return "[{code}] {msg}".format(code=code, msg=msg)
<add> else:
<add> return super().__getattribute__(code)
<ide>
<ide> return ErrorsWithCodes()
<ide>
<ide><path>spacy/tests/test_errors.py
<add>from inspect import isclass
<add>
<add>from spacy.errors import add_codes
<add>
<add>
<add>@add_codes
<add>class Errors(object):
<add> E001 = "error description"
<add>
<add>
<add>def test_add_codes():
<add> assert Errors.E001 == "[E001] error description"
<add> assert isclass(Errors.__class__) | 2 |
Ruby | Ruby | use the correct table name from fixture | 64f106dfd1bcff13882ef2be44585f68c6cb9950 | <ide><path>activerecord/lib/active_record/fixtures.rb
<ide> def self.create_fixtures(fixtures_directory, table_names, class_names = {})
<ide>
<ide> # Cap primary key sequences to max(pk).
<ide> if connection.respond_to?(:reset_pk_sequence!)
<del> table_names.each do |table_name|
<del> connection.reset_pk_sequence!(table_name.tr('/', '_'))
<add> fixture_files.each do |ff|
<add> connection.reset_pk_sequence!(ff.table_name)
<ide> end
<ide> end
<ide> end | 1 |
Text | Text | use es6 in language tooling doc | eddcee9884c2ccd849b6d1b1b5dccc966c47ae8e | <ide><path>docs/docs/09.1-language-tooling.md
<ide> Example output:
<ide>
<ide> ```
<ide> $ cat test.js
<del>var HelloMessage = React.createClass({
<del> render: function() {
<del> return <div>Hello {this.props.name}</div>;
<del> }
<del>});
<add>function HelloMessage(props) {
<add> return <div>Hello {props.name}</div>;
<add>}
<ide>
<ide> ReactDOM.render(<HelloMessage name="John" />, mountNode);
<add>
<ide> $ babel test.js
<ide> "use strict";
<ide>
<del>var HelloMessage = React.createClass({
<del> displayName: "HelloMessage",
<del>
<del> render: function render() {
<del> return React.createElement(
<del> "div",
<del> null,
<del> "Hello ",
<del> this.props.name
<del> );
<del> }
<del>});
<add>function HelloMessage(props) {
<add> return React.createElement(
<add> "div",
<add> null,
<add> "Hello ",
<add> props.name
<add> );
<add>}
<ide>
<ide> ReactDOM.render(React.createElement(HelloMessage, { name: "John" }), mountNode);
<ide> ``` | 1 |
PHP | PHP | implement the pipingdispatcher contract | 8ff29231212e9b2d8c078b7037f382d68cccb51b | <ide><path>src/Illuminate/Bus/Dispatcher.php
<ide> use Illuminate\Contracts\Container\Container;
<ide> use Illuminate\Contracts\Bus\HandlerResolver;
<ide> use Illuminate\Contracts\Queue\ShouldBeQueued;
<add>use Illuminate\Contracts\Bus\PipingDispatcher;
<ide> use Illuminate\Contracts\Bus\QueueingDispatcher;
<ide> use Illuminate\Contracts\Bus\Dispatcher as DispatcherContract;
<ide>
<del>class Dispatcher implements DispatcherContract, QueueingDispatcher, HandlerResolver {
<add>class Dispatcher implements DispatcherContract, QueueingDispatcher, HandlerResolver, PipingDispatcher {
<ide>
<ide> /**
<ide> * The container implementation. | 1 |
Javascript | Javascript | ensure text() stream consumer flushes correctly | ca19775d0ee0ce0863b46e3c76f00f3018b1e19f | <ide><path>lib/stream/consumers.js
<ide> async function text(stream) {
<ide> else
<ide> str += dec.decode(chunk, { stream: true });
<ide> }
<add> // Flush the streaming TextDecoder so that any pending
<add> // incomplete multibyte characters are handled.
<add> str += dec.decode(undefined, { stream: false });
<ide> return str;
<ide> }
<ide>
<ide><path>test/parallel/test-stream-consumers.js
<ide> const kArrayBuffer =
<ide> stream.write({});
<ide> stream.end({});
<ide> }
<add>
<add>{
<add> const stream = new TransformStream();
<add> text(stream.readable).then(common.mustCall((str) => {
<add> // Incomplete utf8 character is flushed as a replacement char
<add> assert.strictEqual(str.charCodeAt(0), 0xfffd);
<add> }));
<add> const writer = stream.writable.getWriter();
<add> Promise.all([
<add> writer.write(new Uint8Array([0xe2])),
<add> writer.write(new Uint8Array([0x82])),
<add> writer.close(),
<add> ]).then(common.mustCall());
<add>} | 2 |
Ruby | Ruby | pass a type caster when aliasing tables for joins | 7931c96338353adc0ebfc780769ef3cd06ab0d79 | <ide><path>activerecord/lib/active_record/associations/alias_tracker.rb
<ide> def initialize(connection, aliases)
<ide> @connection = connection
<ide> end
<ide>
<del> def aliased_table_for(table_name, aliased_name)
<add> def aliased_table_for(table_name, aliased_name, **table_options)
<ide> if aliases[table_name].zero?
<ide> # If it's zero, we can have our table_name
<ide> aliases[table_name] = 1
<del> Arel::Table.new(table_name)
<add> Arel::Table.new(table_name, table_options)
<ide> else
<ide> # Otherwise, we need to use an alias
<ide> aliased_name = connection.table_alias_for(aliased_name)
<ide> def aliased_table_for(table_name, aliased_name)
<ide> else
<ide> aliased_name
<ide> end
<del> Arel::Table.new(table_name).alias(table_alias)
<add> Arel::Table.new(table_name, table_options).alias(table_alias)
<ide> end
<ide> end
<ide>
<ide><path>activerecord/lib/active_record/associations/association_scope.rb
<ide> def construct_tables(chain, klass, refl, alias_tracker)
<ide> chain.map do |reflection|
<ide> alias_tracker.aliased_table_for(
<ide> table_name_for(reflection, klass, refl),
<del> table_alias_for(reflection, refl, reflection != refl)
<add> table_alias_for(reflection, refl, reflection != refl),
<add> type_caster: klass.type_caster,
<ide> )
<ide> end
<ide> end
<ide><path>activerecord/lib/active_record/associations/join_dependency.rb
<ide> def self.walk_tree(associations, hash)
<ide> #
<ide> def initialize(base, associations, joins)
<ide> @alias_tracker = AliasTracker.create(base.connection, joins)
<del> @alias_tracker.aliased_table_for(base.table_name, base.table_name) # Updates the count for base.table_name to 1
<add> @alias_tracker.aliased_table_for(base.table_name, base.table_name, type_caster: base.type_caster) # Updates the count for base.table_name to 1
<ide> tree = self.class.make_tree associations
<ide> @join_root = JoinBase.new base, build(tree, base)
<ide> @join_root.children.each { |child| construct_tables! @join_root, child }
<ide> def make_inner_joins(parent, child)
<ide>
<ide> def table_aliases_for(parent, node)
<ide> node.reflection.chain.map { |reflection|
<add> if reflection.klass
<add> type_caster = reflection.klass.type_caster
<add> end
<ide> alias_tracker.aliased_table_for(
<ide> reflection.table_name,
<del> table_alias_for(reflection, parent, reflection != node.reflection)
<add> table_alias_for(reflection, parent, reflection != node.reflection),
<add> type_caster: type_caster,
<ide> )
<ide> }
<ide> end
<ide><path>activerecord/lib/active_record/core.rb
<ide> def predicate_builder # :nodoc:
<ide> @predicate_builder ||= PredicateBuilder.new(table_metadata)
<ide> end
<ide>
<add> def type_caster # :nodoc:
<add> TypeCaster::Map.new(self)
<add> end
<add>
<ide> private
<ide>
<ide> def relation # :nodoc:
<ide> def relation # :nodoc:
<ide> def table_metadata # :nodoc:
<ide> TableMetadata.new(self, arel_table)
<ide> end
<del>
<del> def type_caster # :nodoc:
<del> TypeCaster::Map.new(self)
<del> end
<ide> end
<ide>
<ide> # New objects can be instantiated as either empty (pass no construction parameter) or pre-set with | 4 |
PHP | PHP | remove flaky test that was of questionable value | a098d96c94df99d8136f2959b8c7abab0c4c6529 | <ide><path>lib/Cake/Test/Case/Utility/ValidationTest.php
<ide> public function testEmailDeep() {
<ide>
<ide> $this->assertTrue(Validation::email('[email protected]', true));
<ide> $this->assertFalse(Validation::email('[email protected]', true));
<del> $this->assertFalse(Validation::email('[email protected]', true));
<ide> }
<ide>
<ide> /** | 1 |
Ruby | Ruby | ensure homebrew_prefix/bin in test path | d89c870621fb78f3b9be4e0758031bcd6bbc3c31 | <ide><path>Library/Homebrew/formula.rb
<ide> def run_test
<ide> old_temp = ENV["TEMP"]
<ide> old_tmp = ENV["TMP"]
<ide> old_term = ENV["TERM"]
<del> old_path = ENV["HOMEBREW_PATH"]
<add> old_path = ENV["PATH"]
<add> old_homebrew_path = ENV["HOMEBREW_PATH"]
<ide>
<ide> ENV["CURL_HOME"] = old_curl_home || old_home
<ide> ENV["TMPDIR"] = ENV["TEMP"] = ENV["TMP"] = HOMEBREW_TEMP
<ide> ENV["TERM"] = "dumb"
<add> ENV["PATH"] = PATH.new(old_path).append(HOMEBREW_PREFIX/"bin")
<ide> ENV["HOMEBREW_PATH"] = nil
<ide>
<ide> ENV.clear_sensitive_environment!
<ide> def run_test
<ide> ENV["TEMP"] = old_temp
<ide> ENV["TMP"] = old_tmp
<ide> ENV["TERM"] = old_term
<del> ENV["HOMEBREW_PATH"] = old_path
<add> ENV["PATH"] = old_path
<add> ENV["HOMEBREW_PATH"] = old_homebrew_path
<ide> @prefix_returns_versioned_prefix = false
<ide> end
<ide> | 1 |
Python | Python | add some comments to the processlist.py | e135dc339fe00c769ad224c0fe722176599890c8 | <ide><path>glances/processes.py
<ide> def update(self):
<ide>
<ide> # Grab standard stats
<ide> #####################
<add> sorted_attrs = ['cpu_percent', 'cpu_times',
<add> 'memory_percent', 'name',
<add> 'status', 'status', 'num_threads']
<add> displayed_attr = ['memory_info', 'nice', 'pid', 'ppid']
<ide> cached_attrs = ['cmdline', 'username']
<ide>
<del> standard_attrs = ['cpu_percent', 'cpu_times', 'memory_info',
<del> 'memory_percent', 'name', 'nice', 'pid', 'ppid',
<del> 'status', 'status', 'num_threads']
<add> # Some stats are optionals
<add> if not self.disable_io_counters:
<add> sorted_attrs.append('io_counters')
<add> if not self.disable_gids:
<add> displayed_attr.append('gids')
<add> # Some stats are not sort key
<add> # An optimisation can be done be only grabed displayed_attr
<add> # for displayed processes (but only in standalone mode...)
<add> sorted_attrs.extend(displayed_attr)
<add> # Some stats are cached (not necessary to be refreshed every time)
<ide> if self.cache_timer.finished():
<del> standard_attrs += cached_attrs
<add> sorted_attrs += cached_attrs
<ide> self.cache_timer.set(self.cache_timeout)
<ide> self.cache_timer.reset()
<ide> is_cached = False
<ide> else:
<ide> is_cached = True
<ide>
<del> if not self.disable_io_counters:
<del> standard_attrs += ['io_counters']
<del> if not self.disable_gids:
<del> standard_attrs += ['gids']
<del>
<del> # and build the processes stats list (psutil>=5.3.0)
<add> # Build the processes stats list (it is why we need psutil>=5.3.0)
<ide> self.processlist = [p.info
<del> for p in psutil.process_iter(attrs=standard_attrs,
<add> for p in psutil.process_iter(attrs=sorted_attrs,
<ide> ad_value=None)
<ide> # OS-related processes filter
<ide> if not (BSD and p.info['name'] == 'idle') and | 1 |
Ruby | Ruby | add support for namespaced validators | 972011a2e58be5caf84bf06dd954ba095c823984 | <ide><path>activemodel/lib/active_model/validations/validates.rb
<ide> module ClassMethods
<ide> # validates :name, :title => true
<ide> # end
<ide> #
<add> # Additionally validator classes may be in another namespace and still used within any class.
<add> #
<add> # validates :name, :'file/title' => true
<add> #
<ide> # The validators hash can also handle regular expressions, ranges,
<ide> # arrays and strings in shortcut form, e.g.
<ide> #
<ide> def validates(*attributes)
<ide> defaults.merge!(:attributes => attributes)
<ide>
<ide> validations.each do |key, options|
<add> key = "#{key.to_s.camelize}Validator"
<add>
<ide> begin
<del> validator = const_get("#{key.to_s.camelize}Validator")
<add> validator = key.include?('::') ? key.constantize : const_get(key)
<ide> rescue NameError
<ide> raise ArgumentError, "Unknown validator: '#{key}'"
<ide> end
<ide><path>activemodel/test/cases/validations/validates_test.rb
<ide> require 'models/person'
<ide> require 'models/person_with_validator'
<ide> require 'validators/email_validator'
<add>require 'validators/namespace/email_validator'
<ide>
<ide> class ValidatesTest < ActiveModel::TestCase
<ide> setup :reset_callbacks
<ide> def test_validates_with_validator_class
<ide> assert_equal ['is not an email'], person.errors[:karma]
<ide> end
<ide>
<add> def test_validates_with_namespaced_validator_class
<add> Person.validates :karma, :'namespace/email' => true
<add> person = Person.new
<add> person.valid?
<add> assert_equal ['is not an email'], person.errors[:karma]
<add> end
<add>
<ide> def test_validates_with_if_as_local_conditions
<ide> Person.validates :karma, :presence => true, :email => { :unless => :condition_is_true }
<ide> person = Person.new
<ide><path>activemodel/test/validators/namespace/email_validator.rb
<add>require 'validators/email_validator'
<add>
<add>module Namespace
<add> class EmailValidator < ::EmailValidator
<add> end
<add>end | 3 |
Javascript | Javascript | add extra info to authentication | aed7f643e2d60a3eb58ff23e038b029afe00241c | <ide><path>examples/with-cookie-auth/www/utils/auth.js
<ide> export const withAuthSync = WrappedComponent =>
<ide> export const auth = ctx => {
<ide> const { token } = nextCookie(ctx)
<ide>
<add> /*
<add> * This happens on server only, ctx.req is available means it's being
<add> * rendered on server. If we are on server and token is not available,
<add> * means user is not logged in.
<add> */
<ide> if (ctx.req && !token) {
<ide> ctx.res.writeHead(302, { Location: '/login' })
<ide> ctx.res.end()
<ide> return
<ide> }
<ide>
<add> // We already checked for server. This should only happen on client.
<ide> if (!token) {
<ide> Router.push('/login')
<ide> } | 1 |
Javascript | Javascript | add url to jquery.event deprecation | 9657caeb9d8519705a5820aa7a21885aa670e851 | <ide><path>packages/ember-views/lib/system/jquery_event_deprecation.js
<ide> export default function addJQueryEventDeprecation(jqEvent) {
<ide> {
<ide> id: 'ember-views.event-dispatcher.jquery-event',
<ide> until: '4.0.0',
<add> url: 'https://emberjs.com/deprecations/v3.x#toc_jquery-event',
<ide> }
<ide> );
<ide> return target[name]; | 1 |
PHP | PHP | apply fixes from styleci | e6471a6f2e73dd244f957751ab315aa5903c32ea | <ide><path>database/factories/UserFactory.php
<ide> |
<ide> */
<ide>
<del>/** @var \Illuminate\Database\Eloquent\Factory $factory */
<add>/* @var \Illuminate\Database\Eloquent\Factory $factory */
<ide>
<ide> $factory->define(User::class, function (Faker $faker) {
<ide> return [ | 1 |
Javascript | Javascript | add systrace to all performancelogger.js markers | e81258a15b076d2805912fae11351311c412ad5e | <ide><path>Libraries/Utilities/PerformanceLogger.js
<ide>
<ide> const BatchedBridge = require('BatchedBridge');
<ide> const performanceNow = global.nativePerformanceNow || require('fbjs/lib/performanceNow');
<add>const Systrace = require('Systrace');
<ide>
<ide> var timespans = {};
<ide> var extras = {};
<add>var cookies = {};
<ide>
<ide> /**
<ide> * This is meant to collect and log performance data in production, which means
<ide> var PerformanceLogger = {
<ide> description: description,
<ide> startTime: performanceNow(),
<ide> };
<add> cookies[key] = Systrace.beginAsyncEvent(key);
<ide> },
<ide>
<ide> stopTimespan(key) {
<ide> var PerformanceLogger = {
<ide> return;
<ide> }
<ide>
<add> Systrace.endAsyncEvent(key, cookies[key]);
<add> delete cookies[key];
<ide> timespans[key].endTime = performanceNow();
<ide> timespans[key].totalTime =
<ide> timespans[key].endTime - timespans[key].startTime; | 1 |
Java | Java | add bigdecimal support for spel numeric operations | d0ab131a57b2dc0cec6b379d439ceff912d5c3d1 | <ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/OpDec.java
<ide>
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.Operation;
<ide> import org.springframework.expression.TypedValue;
<ide> * appropriate exceptions if the operand in question does not support decrement.
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.2
<ide> */
<ide> public class OpDec extends Operator {
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
<ide>
<ide> if (operandValue instanceof Number) {
<ide> Number op1 = (Number) operandValue;
<del> if (op1 instanceof Double) {
<add> if (op1 instanceof BigDecimal) {
<add> newValue = new TypedValue(((BigDecimal) op1).subtract(BigDecimal.ONE),
<add> operandTypedValue.getTypeDescriptor());
<add> }
<add> else if (op1 instanceof Double) {
<ide> newValue = new TypedValue(op1.doubleValue() - 1.0d,
<ide> operandTypedValue.getTypeDescriptor());
<ide> }
<ide> else if (op1 instanceof Short) {
<ide> operandTypedValue.getTypeDescriptor());
<ide> }
<ide> }
<del> if (newValue==null) {
<add> if (newValue == null) {
<ide> try {
<ide> newValue = state.operate(Operation.SUBTRACT, returnValue.getValue(), 1);
<ide> }
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/OpDivide.java
<ide>
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>import java.math.RoundingMode;
<add>
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.Operation;
<ide> import org.springframework.expression.TypedValue;
<ide> import org.springframework.expression.spel.ExpressionState;
<add>import org.springframework.util.NumberUtils;
<ide>
<ide> /**
<ide> * Implements division operator.
<ide> *
<ide> * @author Andy Clement
<ide> * @author Juergen Hoeller
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public class OpDivide extends Operator {
<ide>
<add>
<ide> public OpDivide(int pos, SpelNodeImpl... operands) {
<ide> super("/", pos, operands);
<ide> }
<ide>
<ide>
<ide> @Override
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
<del> Object operandOne = getLeftOperand().getValueInternal(state).getValue();
<del> Object operandTwo = getRightOperand().getValueInternal(state).getValue();
<del> if (operandOne instanceof Number && operandTwo instanceof Number) {
<del> Number op1 = (Number) operandOne;
<del> Number op2 = (Number) operandTwo;
<del> if (op1 instanceof Double || op2 instanceof Double) {
<del> return new TypedValue(op1.doubleValue() / op2.doubleValue());
<add> Object leftOperand = getLeftOperand().getValueInternal(state).getValue();
<add> Object rightOperand = getRightOperand().getValueInternal(state).getValue();
<add>
<add> if (leftOperand instanceof Number && rightOperand instanceof Number) {
<add> Number leftNumber = (Number) leftOperand;
<add> Number rightNumber = (Number) rightOperand;
<add>
<add> if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
<add> BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
<add> BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
<add> int scale = Math.max(leftBigDecimal.scale(), rightBigDecimal.scale());
<add> return new TypedValue(leftBigDecimal.divide(rightBigDecimal, scale, RoundingMode.HALF_EVEN));
<ide> }
<del> else if (op1 instanceof Float || op2 instanceof Float) {
<del> return new TypedValue(op1.floatValue() / op2.floatValue());
<add>
<add> if (leftNumber instanceof Double || rightNumber instanceof Double) {
<add> return new TypedValue(leftNumber.doubleValue() / rightNumber.doubleValue());
<ide> }
<del> else if (op1 instanceof Long || op2 instanceof Long) {
<del> return new TypedValue(op1.longValue() / op2.longValue());
<add> if (leftNumber instanceof Float || rightNumber instanceof Float) {
<add> return new TypedValue(leftNumber.floatValue() / rightNumber.floatValue());
<ide> }
<del> else {
<del> // TODO what about non-int result of the division?
<del> return new TypedValue(op1.intValue() / op2.intValue());
<add> if (leftNumber instanceof Long || rightNumber instanceof Long) {
<add> return new TypedValue(leftNumber.longValue() / rightNumber.longValue());
<ide> }
<add>
<add> // TODO what about non-int result of the division?
<add> return new TypedValue(leftNumber.intValue() / rightNumber.intValue());
<ide> }
<del> return state.operate(Operation.DIVIDE, operandOne, operandTwo);
<add>
<add> return state.operate(Operation.DIVIDE, leftOperand, rightOperand);
<ide> }
<ide>
<ide> }
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/OpGE.java
<ide> */
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.spel.ExpressionState;
<ide> import org.springframework.expression.spel.support.BooleanTypedValue;
<add>import org.springframework.util.NumberUtils;
<ide>
<ide> /**
<ide> * Implements greater-than-or-equal operator.
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public class OpGE extends Operator {
<ide>
<add>
<ide> public OpGE(int pos, SpelNodeImpl... operands) {
<ide> super(">=", pos, operands);
<ide> }
<ide> public BooleanTypedValue getValueInternal(ExpressionState state) throws Evaluati
<ide> if (left instanceof Number && right instanceof Number) {
<ide> Number leftNumber = (Number) left;
<ide> Number rightNumber = (Number) right;
<add>
<add> if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
<add> BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
<add> BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
<add> return BooleanTypedValue.forValue(leftBigDecimal.compareTo(rightBigDecimal) >= 0);
<add> }
<add>
<ide> if (leftNumber instanceof Double || rightNumber instanceof Double) {
<ide> return BooleanTypedValue.forValue(leftNumber.doubleValue() >= rightNumber.doubleValue());
<ide> }
<del> else if (leftNumber instanceof Float || rightNumber instanceof Float) {
<add>
<add> if (leftNumber instanceof Float || rightNumber instanceof Float) {
<ide> return BooleanTypedValue.forValue(leftNumber.floatValue() >= rightNumber.floatValue());
<ide> }
<del> else if (leftNumber instanceof Long || rightNumber instanceof Long) {
<add>
<add> if (leftNumber instanceof Long || rightNumber instanceof Long) {
<ide> return BooleanTypedValue.forValue(leftNumber.longValue() >= rightNumber.longValue());
<ide> }
<del> else {
<del> return BooleanTypedValue.forValue(leftNumber.intValue() >= rightNumber.intValue());
<del> }
<add> return BooleanTypedValue.forValue(leftNumber.intValue() >= rightNumber.intValue());
<ide> }
<ide> return BooleanTypedValue.forValue(state.getTypeComparator().compare(left, right) >= 0);
<ide> }
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/OpGT.java
<ide>
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.spel.ExpressionState;
<ide> import org.springframework.expression.spel.support.BooleanTypedValue;
<add>import org.springframework.util.NumberUtils;
<ide>
<ide> /**
<ide> * Implements greater-than operator.
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public class OpGT extends Operator {
<ide> public OpGT(int pos, SpelNodeImpl... operands) {
<ide> public BooleanTypedValue getValueInternal(ExpressionState state) throws EvaluationException {
<ide> Object left = getLeftOperand().getValueInternal(state).getValue();
<ide> Object right = getRightOperand().getValueInternal(state).getValue();
<add>
<ide> if (left instanceof Number && right instanceof Number) {
<ide> Number leftNumber = (Number) left;
<ide> Number rightNumber = (Number) right;
<add>
<add> if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
<add> BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
<add> BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
<add> return BooleanTypedValue.forValue(leftBigDecimal.compareTo(rightBigDecimal) > 0);
<add> }
<add>
<ide> if (leftNumber instanceof Double || rightNumber instanceof Double) {
<ide> return BooleanTypedValue.forValue(leftNumber.doubleValue() > rightNumber.doubleValue());
<ide> }
<del> else if (leftNumber instanceof Float || rightNumber instanceof Float) {
<add>
<add> if (leftNumber instanceof Float || rightNumber instanceof Float) {
<ide> return BooleanTypedValue.forValue(leftNumber.floatValue() > rightNumber.floatValue());
<ide> }
<del> else if (leftNumber instanceof Long || rightNumber instanceof Long) {
<add>
<add> if (leftNumber instanceof Long || rightNumber instanceof Long) {
<ide> return BooleanTypedValue.forValue(leftNumber.longValue() > rightNumber.longValue());
<ide> }
<del> else {
<del> return BooleanTypedValue.forValue(leftNumber.intValue() > rightNumber.intValue());
<del> }
<add>
<add> return BooleanTypedValue.forValue(leftNumber.intValue() > rightNumber.intValue());
<ide> }
<ide> return BooleanTypedValue.forValue(state.getTypeComparator().compare(left, right) > 0);
<ide> }
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/OpInc.java
<ide>
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.Operation;
<ide> import org.springframework.expression.TypedValue;
<ide> * appropriate exceptions if the operand in question does not support increment.
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.2
<ide> */
<ide> public class OpInc extends Operator {
<ide> public OpInc(int pos, boolean postfix, SpelNodeImpl... operands) {
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
<ide> SpelNodeImpl operand = getLeftOperand();
<ide>
<del> ValueRef lvalue = operand.getValueRef(state);
<add> ValueRef valueRef = operand.getValueRef(state);
<ide>
<del> final TypedValue operandTypedValue = lvalue.getValue();
<del> final Object operandValue = operandTypedValue.getValue();
<del> TypedValue returnValue = operandTypedValue;
<add> final TypedValue typedValue = valueRef.getValue();
<add> final Object value = typedValue.getValue();
<add> TypedValue returnValue = typedValue;
<ide> TypedValue newValue = null;
<ide>
<del> if (operandValue instanceof Number) {
<del> Number op1 = (Number) operandValue;
<del> if (op1 instanceof Double) {
<add> if (value instanceof Number) {
<add> Number op1 = (Number) value;
<add> if (op1 instanceof BigDecimal) {
<add> newValue = new TypedValue(((BigDecimal) op1).add(BigDecimal.ONE),
<add> typedValue.getTypeDescriptor());
<add> }
<add> else if (op1 instanceof Double) {
<ide> newValue = new TypedValue(op1.doubleValue() + 1.0d,
<del> operandTypedValue.getTypeDescriptor());
<add> typedValue.getTypeDescriptor());
<ide> }
<ide> else if (op1 instanceof Float) {
<ide> newValue = new TypedValue(op1.floatValue() + 1.0f,
<del> operandTypedValue.getTypeDescriptor());
<add> typedValue.getTypeDescriptor());
<ide> }
<ide> else if (op1 instanceof Long) {
<ide> newValue = new TypedValue(op1.longValue() + 1L,
<del> operandTypedValue.getTypeDescriptor());
<add> typedValue.getTypeDescriptor());
<ide> }
<ide> else if (op1 instanceof Short) {
<ide> newValue = new TypedValue(op1.shortValue() + (short) 1,
<del> operandTypedValue.getTypeDescriptor());
<add> typedValue.getTypeDescriptor());
<ide> }
<ide> else {
<ide> newValue = new TypedValue(op1.intValue() + 1,
<del> operandTypedValue.getTypeDescriptor());
<add> typedValue.getTypeDescriptor());
<ide> }
<ide> }
<ide> if (newValue == null) {
<ide> else if (op1 instanceof Short) {
<ide>
<ide> // set the name value
<ide> try {
<del> lvalue.setValue(newValue.getValue());
<add> valueRef.setValue(newValue.getValue());
<ide> }
<ide> catch (SpelEvaluationException see) {
<ide> // if unable to set the value the operand is not writable (e.g. 1++ )
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/OpLE.java
<ide>
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.spel.ExpressionState;
<ide> import org.springframework.expression.spel.support.BooleanTypedValue;
<add>import org.springframework.util.NumberUtils;
<ide>
<ide> /**
<ide> * Implements the less-than-or-equal operator.
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public class OpLE extends Operator {
<ide>
<add>
<ide> public OpLE(int pos, SpelNodeImpl... operands) {
<ide> super("<=", pos, operands);
<ide> }
<ide> public BooleanTypedValue getValueInternal(ExpressionState state)
<ide> if (left instanceof Number && right instanceof Number) {
<ide> Number leftNumber = (Number) left;
<ide> Number rightNumber = (Number) right;
<add>
<add> if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
<add> BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
<add> BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
<add> return BooleanTypedValue.forValue(leftBigDecimal.compareTo(rightBigDecimal) <= 0);
<add> }
<add>
<ide> if (leftNumber instanceof Double || rightNumber instanceof Double) {
<ide> return BooleanTypedValue.forValue(leftNumber.doubleValue() <= rightNumber.doubleValue());
<ide> }
<del> else if (leftNumber instanceof Float || rightNumber instanceof Float) {
<add>
<add> if (leftNumber instanceof Float || rightNumber instanceof Float) {
<ide> return BooleanTypedValue.forValue(leftNumber.floatValue() <= rightNumber.floatValue());
<ide> }
<del> else if (leftNumber instanceof Long || rightNumber instanceof Long) {
<add>
<add> if (leftNumber instanceof Long || rightNumber instanceof Long) {
<ide> return BooleanTypedValue.forValue(leftNumber.longValue() <= rightNumber.longValue());
<ide> }
<del> else {
<del> return BooleanTypedValue.forValue(leftNumber.intValue() <= rightNumber.intValue());
<del> }
<add>
<add> return BooleanTypedValue.forValue(leftNumber.intValue() <= rightNumber.intValue());
<ide> }
<add>
<ide> return BooleanTypedValue.forValue(state.getTypeComparator().compare(left, right) <= 0);
<ide> }
<ide>
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/OpLT.java
<ide>
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.spel.ExpressionState;
<ide> import org.springframework.expression.spel.support.BooleanTypedValue;
<add>import org.springframework.util.NumberUtils;
<ide>
<ide> /**
<ide> * Implements the less-than operator.
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public class OpLT extends Operator {
<ide> public BooleanTypedValue getValueInternal(ExpressionState state)
<ide> if (left instanceof Number && right instanceof Number) {
<ide> Number leftNumber = (Number) left;
<ide> Number rightNumber = (Number) right;
<add>
<add> if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
<add> BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
<add> BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
<add> return BooleanTypedValue.forValue(leftBigDecimal.compareTo(rightBigDecimal) < 0);
<add> }
<add>
<ide> if (leftNumber instanceof Double || rightNumber instanceof Double) {
<ide> return BooleanTypedValue.forValue(leftNumber.doubleValue() < rightNumber.doubleValue());
<ide> }
<del> else if (leftNumber instanceof Float || rightNumber instanceof Float) {
<add>
<add> if (leftNumber instanceof Float || rightNumber instanceof Float) {
<ide> return BooleanTypedValue.forValue(leftNumber.floatValue() < rightNumber.floatValue());
<ide> }
<del> else if (leftNumber instanceof Long || rightNumber instanceof Long) {
<add>
<add> if (leftNumber instanceof Long || rightNumber instanceof Long) {
<ide> return BooleanTypedValue.forValue(leftNumber.longValue() < rightNumber.longValue());
<ide> }
<del> else {
<del> return BooleanTypedValue.forValue(leftNumber.intValue() < rightNumber.intValue());
<del> }
<add>
<add> return BooleanTypedValue.forValue(leftNumber.intValue() < rightNumber.intValue());
<ide> }
<ide> return BooleanTypedValue.forValue(state.getTypeComparator().compare(left, right) < 0);
<ide> }
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/OpMinus.java
<ide>
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.Operation;
<ide> import org.springframework.expression.TypedValue;
<ide> import org.springframework.expression.spel.ExpressionState;
<add>import org.springframework.util.NumberUtils;
<ide>
<ide> /**
<ide> * The minus operator supports:
<ide> * <ul>
<add> * <li>subtraction of {@code BigDecimal}
<ide> * <li>subtraction of doubles (floats are represented as doubles)
<ide> * <li>subtraction of longs
<ide> * <li>subtraction of integers
<ide> * <li>subtraction of an int from a string of one character (effectively decreasing that
<ide> * character), so 'd'-3='a'
<ide> * </ul>
<del> * It can be used as a unary operator for numbers (double/long/int). The standard
<del> * promotions are performed when the operand types vary (double-int=double). For other
<del> * options it defers to the registered overloader.
<add> * It can be used as a unary operator for numbers ({@code BigDecimal}/double/long/int).
<add> * The standard promotions are performed when the operand types vary (double-int=double).
<add> * For other options it defers to the registered overloader.
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public class OpMinus extends Operator {
<ide>
<add>
<ide> public OpMinus(int pos, SpelNodeImpl... operands) {
<ide> super("-", pos, operands);
<ide> }
<ide>
<add>
<ide> @Override
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
<ide>
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
<ide> Object operand = leftOp.getValueInternal(state).getValue();
<ide> if (operand instanceof Number) {
<ide> Number n = (Number) operand;
<add>
<add> if (operand instanceof BigDecimal) {
<add> BigDecimal bdn = (BigDecimal) n;
<add> return new TypedValue(bdn.negate());
<add> }
<add>
<ide> if (operand instanceof Double) {
<ide> return new TypedValue(0 - n.doubleValue());
<ide> }
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
<ide> if (operand instanceof Long) {
<ide> return new TypedValue(0 - n.longValue());
<ide> }
<add>
<ide> return new TypedValue(0 - n.intValue());
<ide> }
<ide>
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
<ide> Object right = rightOp.getValueInternal(state).getValue();
<ide>
<ide> if (left instanceof Number && right instanceof Number) {
<del> Number op1 = (Number) left;
<del> Number op2 = (Number) right;
<del> if (op1 instanceof Double || op2 instanceof Double) {
<del> return new TypedValue(op1.doubleValue() - op2.doubleValue());
<add> Number leftNumber = (Number) left;
<add> Number rightNumber = (Number) right;
<add>
<add> if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
<add> BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
<add> BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
<add> return new TypedValue(leftBigDecimal.subtract(rightBigDecimal));
<add> }
<add>
<add> if (leftNumber instanceof Double || rightNumber instanceof Double) {
<add> return new TypedValue(leftNumber.doubleValue() - rightNumber.doubleValue());
<ide> }
<ide>
<del> if (op1 instanceof Float || op2 instanceof Float) {
<del> return new TypedValue(op1.floatValue() - op2.floatValue());
<add> if (leftNumber instanceof Float || rightNumber instanceof Float) {
<add> return new TypedValue(leftNumber.floatValue() - rightNumber.floatValue());
<ide> }
<ide>
<del> if (op1 instanceof Long || op2 instanceof Long) {
<del> return new TypedValue(op1.longValue() - op2.longValue());
<add> if (leftNumber instanceof Long || rightNumber instanceof Long) {
<add> return new TypedValue(leftNumber.longValue() - rightNumber.longValue());
<ide> }
<ide>
<del> return new TypedValue(op1.intValue() - op2.intValue());
<add> return new TypedValue(leftNumber.intValue() - rightNumber.intValue());
<ide> }
<ide> else if (left instanceof String && right instanceof Integer
<ide> && ((String) left).length() == 1) {
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/OpModulus.java
<ide>
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.Operation;
<ide> import org.springframework.expression.TypedValue;
<ide> import org.springframework.expression.spel.ExpressionState;
<add>import org.springframework.util.NumberUtils;
<ide>
<ide> /**
<ide> * Implements the modulus operator.
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public class OpModulus extends Operator {
<ide>
<add>
<ide> public OpModulus(int pos, SpelNodeImpl... operands) {
<ide> super("%", pos, operands);
<ide> }
<ide>
<ide>
<ide> @Override
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
<del> Object operandOne = getLeftOperand().getValueInternal(state).getValue();
<del> Object operandTwo = getRightOperand().getValueInternal(state).getValue();
<del> if (operandOne instanceof Number && operandTwo instanceof Number) {
<del> Number op1 = (Number) operandOne;
<del> Number op2 = (Number) operandTwo;
<del> if (op1 instanceof Double || op2 instanceof Double) {
<del> return new TypedValue(op1.doubleValue() % op2.doubleValue());
<add> Object leftOperand = getLeftOperand().getValueInternal(state).getValue();
<add> Object rightOperand = getRightOperand().getValueInternal(state).getValue();
<add> if (leftOperand instanceof Number && rightOperand instanceof Number) {
<add> Number leftNumber = (Number) leftOperand;
<add> Number rightNumber = (Number) rightOperand;
<add>
<add> if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
<add> BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
<add> BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
<add> return new TypedValue(leftBigDecimal.remainder(rightBigDecimal));
<ide> }
<del> else if (op1 instanceof Float || op2 instanceof Float) {
<del> return new TypedValue(op1.floatValue() % op2.floatValue());
<add>
<add> if (leftNumber instanceof Double || rightNumber instanceof Double) {
<add> return new TypedValue(leftNumber.doubleValue() % rightNumber.doubleValue());
<ide> }
<del> else if (op1 instanceof Long || op2 instanceof Long) {
<del> return new TypedValue(op1.longValue() % op2.longValue());
<add>
<add> if (leftNumber instanceof Float || rightNumber instanceof Float) {
<add> return new TypedValue(leftNumber.floatValue() % rightNumber.floatValue());
<ide> }
<del> else {
<del> return new TypedValue(op1.intValue() % op2.intValue());
<add>
<add> if (leftNumber instanceof Long || rightNumber instanceof Long) {
<add> return new TypedValue(leftNumber.longValue() % rightNumber.longValue());
<ide> }
<add>
<add> return new TypedValue(leftNumber.intValue() % rightNumber.intValue());
<ide> }
<del> return state.operate(Operation.MODULUS, operandOne, operandTwo);
<add>
<add> return state.operate(Operation.MODULUS, leftOperand, rightOperand);
<ide> }
<ide>
<ide> }
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/OpMultiply.java
<ide>
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.Operation;
<ide> import org.springframework.expression.TypedValue;
<ide> import org.springframework.expression.spel.ExpressionState;
<add>import org.springframework.util.NumberUtils;
<ide>
<ide> /**
<ide> * Implements the {@code multiply} operator.
<ide> *
<ide> * <p>Conversions and promotions are handled as defined in
<ide> * <a href="http://java.sun.com/docs/books/jls/third_edition/html/conversions.html">Section
<del> * 5.6.2 of the Java Language Specification</a>:
<add> * 5.6.2 of the Java Language Specification</a>, with the addiction of {@code BigDecimal} management:
<ide> *
<ide> * <p>If any of the operands is of a reference type, unboxing conversion (Section 5.1.8)
<ide> * is performed. Then:<br>
<add> * If either operand is of type {@code BigDecimal}, the other is converted to {@code BigDecimal}.<br>
<ide> * If either operand is of type double, the other is converted to double.<br>
<ide> * Otherwise, if either operand is of type float, the other is converted to float.<br>
<ide> * Otherwise, if either operand is of type long, the other is converted to long.<br>
<ide> * Otherwise, both operands are converted to type int.
<ide> *
<ide> * @author Andy Clement
<ide> * @author Sam Brannen
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public class OpMultiply extends Operator {
<ide>
<add>
<ide> public OpMultiply(int pos, SpelNodeImpl... operands) {
<ide> super("*", pos, operands);
<ide> }
<ide> public OpMultiply(int pos, SpelNodeImpl... operands) {
<ide> * for types not supported here.
<ide> * <p>Supported operand types:
<ide> * <ul>
<add> * <li>{@code BigDecimal}
<ide> * <li>doubles
<ide> * <li>longs
<ide> * <li>integers
<ide> public OpMultiply(int pos, SpelNodeImpl... operands) {
<ide> @Override
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
<ide>
<del> Object operandOne = getLeftOperand().getValueInternal(state).getValue();
<del> Object operandTwo = getRightOperand().getValueInternal(state).getValue();
<add> Object leftOperand = getLeftOperand().getValueInternal(state).getValue();
<add> Object rightOperand = getRightOperand().getValueInternal(state).getValue();
<add>
<add> if (leftOperand instanceof Number && rightOperand instanceof Number) {
<add> Number leftNumber = (Number) leftOperand;
<add> Number rightNumber = (Number) rightOperand;
<add> if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
<add> BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
<add> BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
<add> return new TypedValue(leftBigDecimal.multiply(rightBigDecimal));
<add> }
<ide>
<del> if (operandOne instanceof Number && operandTwo instanceof Number) {
<del> Number leftNumber = (Number) operandOne;
<del> Number rightNumber = (Number) operandTwo;
<ide> if (leftNumber instanceof Double || rightNumber instanceof Double) {
<del> return new TypedValue(leftNumber.doubleValue()
<del> * rightNumber.doubleValue());
<add> return new TypedValue(leftNumber.doubleValue() * rightNumber.doubleValue());
<ide> }
<ide>
<ide> if (leftNumber instanceof Float || rightNumber instanceof Float) {
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
<ide>
<ide> return new TypedValue(leftNumber.intValue() * rightNumber.intValue());
<ide> }
<del> else if (operandOne instanceof String && operandTwo instanceof Integer) {
<del> int repeats = (Integer) operandTwo;
<add> else if (leftOperand instanceof String && rightOperand instanceof Integer) {
<add> int repeats = (Integer) rightOperand;
<ide> StringBuilder result = new StringBuilder();
<ide> for (int i = 0; i < repeats; i++) {
<del> result.append(operandOne);
<add> result.append(leftOperand);
<ide> }
<ide> return new TypedValue(result.toString());
<ide> }
<ide>
<del> return state.operate(Operation.MULTIPLY, operandOne, operandTwo);
<add> return state.operate(Operation.MULTIPLY, leftOperand, rightOperand);
<ide> }
<ide>
<ide> }
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/OpPlus.java
<ide>
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.core.convert.TypeDescriptor;
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.Operation;
<ide> import org.springframework.expression.TypeConverter;
<ide> import org.springframework.expression.TypedValue;
<ide> import org.springframework.expression.spel.ExpressionState;
<ide> import org.springframework.util.Assert;
<add>import org.springframework.util.NumberUtils;
<ide>
<ide> /**
<ide> * The plus operator will:
<ide> * <ul>
<add> * <li>add {@code BigDecimal}
<ide> * <li>add doubles (floats are represented as doubles)
<ide> * <li>add longs
<ide> * <li>add integers
<ide> * <li>concatenate strings
<ide> * </ul>
<del> * It can be used as a unary operator for numbers (double/long/int). The standard
<del> * promotions are performed when the operand types vary (double+int=double). For other
<del> * options it defers to the registered overloader.
<add> * It can be used as a unary operator for numbers ({@code BigDecimal}/double/long/int).
<add> * The standard promotions are performed when the operand types vary (double+int=double).
<add> * For other options it defers to the registered overloader.
<ide> *
<ide> * @author Andy Clement
<ide> * @author Ivo Smid
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public class OpPlus extends Operator {
<ide>
<add>
<ide> public OpPlus(int pos, SpelNodeImpl... operands) {
<ide> super("+", pos, operands);
<ide> Assert.notEmpty(operands);
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
<ide> if (rightOp == null) { // If only one operand, then this is unary plus
<ide> Object operandOne = leftOp.getValueInternal(state).getValue();
<ide> if (operandOne instanceof Number) {
<del> if (operandOne instanceof Double || operandOne instanceof Long) {
<add> if (operandOne instanceof Double || operandOne instanceof Long || operandOne instanceof BigDecimal) {
<ide> return new TypedValue(operandOne);
<ide> }
<ide> if (operandOne instanceof Float) {
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
<ide> }
<ide>
<ide> final TypedValue operandOneValue = leftOp.getValueInternal(state);
<del> final Object operandOne = operandOneValue.getValue();
<add> final Object leftOperand = operandOneValue.getValue();
<ide>
<ide> final TypedValue operandTwoValue = rightOp.getValueInternal(state);
<del> final Object operandTwo = operandTwoValue.getValue();
<add> final Object rightOperand = operandTwoValue.getValue();
<add>
<add> if (leftOperand instanceof Number && rightOperand instanceof Number) {
<add> Number leftNumber = (Number) leftOperand;
<add> Number rightNumber = (Number) rightOperand;
<add>
<add> if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
<add> BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
<add> BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
<add> return new TypedValue(leftBigDecimal.add(rightBigDecimal));
<add> }
<ide>
<del> if (operandOne instanceof Number && operandTwo instanceof Number) {
<del> Number op1 = (Number) operandOne;
<del> Number op2 = (Number) operandTwo;
<del> if (op1 instanceof Double || op2 instanceof Double) {
<del> return new TypedValue(op1.doubleValue() + op2.doubleValue());
<add> if (leftNumber instanceof Double || rightNumber instanceof Double) {
<add> return new TypedValue(leftNumber.doubleValue() + rightNumber.doubleValue());
<ide> }
<del> if (op1 instanceof Float || op2 instanceof Float) {
<del> return new TypedValue(op1.floatValue() + op2.floatValue());
<add>
<add> if (leftNumber instanceof Float || rightNumber instanceof Float) {
<add> return new TypedValue(leftNumber.floatValue() + rightNumber.floatValue());
<ide> }
<del> if (op1 instanceof Long || op2 instanceof Long) {
<del> return new TypedValue(op1.longValue() + op2.longValue());
<add>
<add> if (leftNumber instanceof Long || rightNumber instanceof Long) {
<add> return new TypedValue(leftNumber.longValue() + rightNumber.longValue());
<ide> }
<add>
<ide> // TODO what about overflow?
<del> return new TypedValue(op1.intValue() + op2.intValue());
<add> return new TypedValue(leftNumber.intValue() + rightNumber.intValue());
<ide> }
<ide>
<del> if (operandOne instanceof String && operandTwo instanceof String) {
<del> return new TypedValue(new StringBuilder((String) operandOne).append(
<del> (String) operandTwo).toString());
<add> if (leftOperand instanceof String && rightOperand instanceof String) {
<add> return new TypedValue(new StringBuilder((String) leftOperand).append(
<add> (String) rightOperand).toString());
<ide> }
<ide>
<del> if (operandOne instanceof String) {
<del> StringBuilder result = new StringBuilder((String) operandOne);
<del> result.append((operandTwo == null ? "null" : convertTypedValueToString(
<add> if (leftOperand instanceof String) {
<add> StringBuilder result = new StringBuilder((String) leftOperand);
<add> result.append((rightOperand == null ? "null" : convertTypedValueToString(
<ide> operandTwoValue, state)));
<ide> return new TypedValue(result.toString());
<ide> }
<ide>
<del> if (operandTwo instanceof String) {
<del> StringBuilder result = new StringBuilder((operandOne == null ? "null"
<add> if (rightOperand instanceof String) {
<add> StringBuilder result = new StringBuilder((leftOperand == null ? "null"
<ide> : convertTypedValueToString(operandOneValue, state)));
<del> result.append((String) operandTwo);
<add> result.append((String) rightOperand);
<ide> return new TypedValue(result.toString());
<ide> }
<ide>
<del> return state.operate(Operation.ADD, operandOne, operandTwo);
<add> return state.operate(Operation.ADD, leftOperand, rightOperand);
<ide> }
<ide>
<ide> @Override
<ide> public String toStringAST() {
<ide> if (this.children.length<2) { // unary plus
<ide> return new StringBuilder().append("+").append(getLeftOperand().toStringAST()).toString();
<ide> }
<del>
<ide> return super.toStringAST();
<ide> }
<ide>
<ide> public SpelNodeImpl getRightOperand() {
<ide> if (this.children.length < 2) {
<ide> return null;
<ide> }
<del>
<ide> return this.children[1];
<ide> }
<ide>
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/Operator.java
<ide>
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.expression.spel.ExpressionState;
<add>import org.springframework.util.NumberUtils;
<add>import org.springframework.util.ObjectUtils;
<ide>
<ide> /**
<ide> * Common supertype for operators that operate on either one or two operands. In the case
<ide> * of multiply or divide there would be two operands, but for unary plus or minus, there
<ide> * is only one.
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public abstract class Operator extends SpelNodeImpl {
<ide> public String toStringAST() {
<ide>
<ide> protected boolean equalityCheck(ExpressionState state, Object left, Object right) {
<ide> if (left instanceof Number && right instanceof Number) {
<del> Number op1 = (Number) left;
<del> Number op2 = (Number) right;
<add> Number leftNumber = (Number) left;
<add> Number rightNumber = (Number) right;
<add>
<add> if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
<add> BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
<add> BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
<add> return (leftBigDecimal == null ? rightBigDecimal == null : leftBigDecimal.compareTo(rightBigDecimal) == 0);
<add> }
<ide>
<del> if (op1 instanceof Double || op2 instanceof Double) {
<del> return (op1.doubleValue() == op2.doubleValue());
<add> if (leftNumber instanceof Double || rightNumber instanceof Double) {
<add> return (leftNumber.doubleValue() == rightNumber.doubleValue());
<ide> }
<ide>
<del> if (op1 instanceof Float || op2 instanceof Float) {
<del> return (op1.floatValue() == op2.floatValue());
<add> if (leftNumber instanceof Float || rightNumber instanceof Float) {
<add> return (leftNumber.floatValue() == rightNumber.floatValue());
<ide> }
<ide>
<del> if (op1 instanceof Long || op2 instanceof Long) {
<del> return (op1.longValue() == op2.longValue());
<add> if (leftNumber instanceof Long || rightNumber instanceof Long) {
<add> return (leftNumber.longValue() == rightNumber.longValue());
<ide> }
<ide>
<del> return (op1.intValue() == op2.intValue());
<add> return (leftNumber.intValue() == rightNumber.intValue());
<ide> }
<ide>
<ide> if (left != null && (left instanceof Comparable)) {
<ide> return (state.getTypeComparator().compare(left, right) == 0);
<ide> }
<ide>
<del> return (left == null ? right == null : left.equals(right));
<add> return ObjectUtils.nullSafeEquals(left, right);
<ide> }
<ide>
<ide> }
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/ast/OperatorPower.java
<ide>
<ide> package org.springframework.expression.spel.ast;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.Operation;
<ide> import org.springframework.expression.TypedValue;
<ide> import org.springframework.expression.spel.ExpressionState;
<add>import org.springframework.util.NumberUtils;
<ide>
<ide> /**
<ide> * The power operator.
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public class OperatorPower extends Operator {
<ide> public TypedValue getValueInternal(ExpressionState state) throws EvaluationExcep
<ide> SpelNodeImpl leftOp = getLeftOperand();
<ide> SpelNodeImpl rightOp = getRightOperand();
<ide>
<del> Object operandOne = leftOp.getValueInternal(state).getValue();
<del> Object operandTwo = rightOp.getValueInternal(state).getValue();
<del> if (operandOne instanceof Number && operandTwo instanceof Number) {
<del> Number op1 = (Number) operandOne;
<del> Number op2 = (Number) operandTwo;
<del> if (op1 instanceof Double || op2 instanceof Double) {
<del> return new TypedValue(Math.pow(op1.doubleValue(), op2.doubleValue()));
<add> Object leftOperand = leftOp.getValueInternal(state).getValue();
<add> Object rightOperand = rightOp.getValueInternal(state).getValue();
<add>
<add> if (leftOperand instanceof Number && rightOperand instanceof Number) {
<add> Number leftNumber = (Number) leftOperand;
<add> Number rightNumber = (Number) rightOperand;
<add>
<add> if (leftNumber instanceof BigDecimal) {
<add> BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
<add> return new TypedValue(leftBigDecimal.pow(rightNumber.intValue()));
<ide> }
<del> else if (op1 instanceof Float || op2 instanceof Float) {
<del> return new TypedValue(Math.pow(op1.floatValue(), op2.floatValue()));
<add>
<add> if (leftNumber instanceof Double || rightNumber instanceof Double) {
<add> return new TypedValue(Math.pow(leftNumber.doubleValue(), rightNumber.doubleValue()));
<add> }
<add>
<add> if (leftNumber instanceof Float || rightNumber instanceof Float) {
<add> return new TypedValue(Math.pow(leftNumber.floatValue(), rightNumber.floatValue()));
<ide> }
<del> else if (op1 instanceof Long || op2 instanceof Long) {
<del> double d = Math.pow(op1.longValue(), op2.longValue());
<add>
<add> if (leftNumber instanceof Long || rightNumber instanceof Long) {
<add> double d = Math.pow(leftNumber.longValue(), rightNumber.longValue());
<add> return new TypedValue((long) d);
<add> }
<add>
<add> double d = Math.pow(leftNumber.longValue(), rightNumber.longValue());
<add> if (d > Integer.MAX_VALUE) {
<ide> return new TypedValue((long) d);
<ide> }
<ide> else {
<del> double d = Math.pow(op1.longValue(), op2.longValue());
<del> if (d > Integer.MAX_VALUE) {
<del> return new TypedValue((long) d);
<del> }
<del> else {
<del> return new TypedValue((int) d);
<del> }
<add> return new TypedValue((int) d);
<ide> }
<ide> }
<del> return state.operate(Operation.POWER, operandOne, operandTwo);
<add>
<add> return state.operate(Operation.POWER, leftOperand, rightOperand);
<ide> }
<ide>
<ide> }
<ide><path>spring-expression/src/main/java/org/springframework/expression/spel/support/StandardTypeComparator.java
<ide>
<ide> package org.springframework.expression.spel.support;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.springframework.expression.TypeComparator;
<ide> import org.springframework.expression.spel.SpelEvaluationException;
<ide> import org.springframework.expression.spel.SpelMessage;
<add>import org.springframework.util.NumberUtils;
<ide>
<ide> /**
<ide> * A simple basic TypeComparator implementation. It supports comparison of numbers and
<ide> * types implementing Comparable.
<ide> *
<ide> * @author Andy Clement
<ide> * @author Juergen Hoeller
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public class StandardTypeComparator implements TypeComparator {
<ide> else if (right == null) {
<ide> if (left instanceof Number && right instanceof Number) {
<ide> Number leftNumber = (Number) left;
<ide> Number rightNumber = (Number) right;
<add>
<add> if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
<add> BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
<add> BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
<add> return leftBigDecimal.compareTo(rightBigDecimal);
<add> }
<add>
<ide> if (leftNumber instanceof Double || rightNumber instanceof Double) {
<del> double d1 = leftNumber.doubleValue();
<del> double d2 = rightNumber.doubleValue();
<del> return Double.compare(d1, d2);
<add> return Double.compare(leftNumber.doubleValue(), rightNumber.doubleValue());
<ide> }
<ide>
<ide> if (leftNumber instanceof Float || rightNumber instanceof Float) {
<del> float f1 = leftNumber.floatValue();
<del> float f2 = rightNumber.floatValue();
<del> return Float.compare(f1, f2);
<add> return Float.compare(leftNumber.floatValue(), rightNumber.floatValue());
<ide> }
<ide>
<ide> if (leftNumber instanceof Long || rightNumber instanceof Long) {
<del> Long l1 = leftNumber.longValue();
<del> Long l2 = rightNumber.longValue();
<del> return l1.compareTo(l2);
<add> return Long.compare(leftNumber.longValue(), rightNumber.longValue());
<ide> }
<ide>
<del> Integer i1 = leftNumber.intValue();
<del> Integer i2 = rightNumber.intValue();
<del> return i1.compareTo(i2);
<add> return Integer.compare(leftNumber.intValue(), rightNumber.intValue());
<ide> }
<ide>
<ide> try {
<ide><path>spring-expression/src/test/java/org/springframework/expression/spel/DefaultComparatorUnitTests.java
<ide> /*
<del> * Copyright 2002-2012 the original author or authors.
<add> * Copyright 2002-2013 the original author or authors.
<ide> *
<ide> * Licensed under the Apache License, Version 2.0 (the "License");
<ide> * you may not use this file except in compliance with the License.
<ide> import static org.junit.Assert.assertFalse;
<ide> import static org.junit.Assert.assertTrue;
<ide>
<add>import java.math.BigDecimal;
<add>
<ide> import org.junit.Test;
<ide> import org.springframework.expression.EvaluationException;
<ide> import org.springframework.expression.TypeComparator;
<ide> * Unit tests for type comparison
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> */
<ide> public class DefaultComparatorUnitTests {
<ide>
<ide> public void testPrimitives() throws EvaluationException {
<ide> assertTrue(comparator.compare(2L, 1L) > 0);
<ide> }
<ide>
<add> @Test
<add> public void testNonPrimitiveNumbers() throws EvaluationException {
<add> TypeComparator comparator = new StandardTypeComparator();
<add>
<add> BigDecimal bdOne = new BigDecimal("1");
<add> BigDecimal bdTwo = new BigDecimal("2");
<add>
<add> assertTrue(comparator.compare(bdOne, bdTwo) < 0);
<add> assertTrue(comparator.compare(bdOne, new BigDecimal("1")) == 0);
<add> assertTrue(comparator.compare(bdTwo, bdOne) > 0);
<add>
<add> assertTrue(comparator.compare(1, bdTwo) < 0);
<add> assertTrue(comparator.compare(1, bdOne) == 0);
<add> assertTrue(comparator.compare(2, bdOne) > 0);
<add>
<add> assertTrue(comparator.compare(1.0d, bdTwo) < 0);
<add> assertTrue(comparator.compare(1.0d, bdOne) == 0);
<add> assertTrue(comparator.compare(2.0d, bdOne) > 0);
<add>
<add> assertTrue(comparator.compare(1.0f, bdTwo) < 0);
<add> assertTrue(comparator.compare(1.0f, bdOne) == 0);
<add> assertTrue(comparator.compare(2.0f, bdOne) > 0);
<add>
<add> assertTrue(comparator.compare(1L, bdTwo) < 0);
<add> assertTrue(comparator.compare(1L, bdOne) == 0);
<add> assertTrue(comparator.compare(2L, bdOne) > 0);
<add>
<add> }
<add>
<ide> @Test
<ide> public void testNulls() throws EvaluationException {
<ide> TypeComparator comparator = new StandardTypeComparator();
<ide><path>spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java
<ide> import static org.junit.Assert.fail;
<ide>
<ide> import java.lang.reflect.Method;
<add>import java.math.BigDecimal;
<ide> import java.util.ArrayList;
<ide> import java.util.List;
<ide> import java.util.Map;
<ide> * @author Mark Fisher
<ide> * @author Sam Brannen
<ide> * @author Phillip Webb
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0
<ide> */
<ide> public class EvaluationTests extends ExpressionTestCase {
<ide> public List<Method> filter(List<Method> methods) {
<ide>
<ide> static class Spr9751 {
<ide> public String type = "hello";
<add> public BigDecimal bd = new BigDecimal("2");
<ide> public double ddd = 2.0d;
<ide> public float fff = 3.0f;
<ide> public long lll = 66666L;
<ide> public void increment02postfix() {
<ide> ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true));
<ide> Expression e = null;
<ide>
<add> // BigDecimal
<add> e = parser.parseExpression("bd++");
<add> assertTrue(new BigDecimal("2").equals(helper.bd));
<add> BigDecimal return_bd = e.getValue(ctx,BigDecimal.class);
<add> assertTrue(new BigDecimal("2").equals(return_bd));
<add> assertTrue(new BigDecimal("3").equals(helper.bd));
<add>
<ide> // double
<ide> e = parser.parseExpression("ddd++");
<ide> assertEquals(2.0d,helper.ddd,0d);
<ide> public void increment02prefix() {
<ide> ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true));
<ide> Expression e = null;
<ide>
<add>
<add> // BigDecimal
<add> e = parser.parseExpression("++bd");
<add> assertTrue(new BigDecimal("2").equals(helper.bd));
<add> BigDecimal return_bd = e.getValue(ctx,BigDecimal.class);
<add> assertTrue(new BigDecimal("3").equals(return_bd));
<add> assertTrue(new BigDecimal("3").equals(helper.bd));
<add>
<ide> // double
<ide> e = parser.parseExpression("++ddd");
<ide> assertEquals(2.0d,helper.ddd,0d);
<ide> public void decrement02postfix() {
<ide> ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true));
<ide> Expression e = null;
<ide>
<add> // BigDecimal
<add> e = parser.parseExpression("bd--");
<add> assertTrue(new BigDecimal("2").equals(helper.bd));
<add> BigDecimal return_bd = e.getValue(ctx,BigDecimal.class);
<add> assertTrue(new BigDecimal("2").equals(return_bd));
<add> assertTrue(new BigDecimal("1").equals(helper.bd));
<add>
<ide> // double
<ide> e = parser.parseExpression("ddd--");
<ide> assertEquals(2.0d,helper.ddd,0d);
<ide> public void decrement02prefix() {
<ide> ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true));
<ide> Expression e = null;
<ide>
<add> // BigDecimal
<add> e = parser.parseExpression("--bd");
<add> assertTrue(new BigDecimal("2").equals(helper.bd));
<add> BigDecimal return_bd = e.getValue(ctx,BigDecimal.class);
<add> assertTrue(new BigDecimal("1").equals(return_bd));
<add> assertTrue(new BigDecimal("1").equals(helper.bd));
<add>
<ide> // double
<ide> e = parser.parseExpression("--ddd");
<ide> assertEquals(2.0d,helper.ddd,0d);
<ide><path>spring-expression/src/test/java/org/springframework/expression/spel/ListTests.java
<ide> /*
<del> * Copyright 2002-2012 the original author or authors.
<add> * Copyright 2002-2013 the original author or authors.
<ide> *
<ide> * Licensed under the Apache License, Version 2.0 (the "License");
<ide> * you may not use this file except in compliance with the License.
<ide> * Test usage of inline lists.
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> * @since 3.0.4
<ide> */
<ide> public class ListTests extends ExpressionTestCase {
<ide> public void testRelOperatorsBetween03() {
<ide> evaluate("42 between {32, 42}", "true", Boolean.class);
<ide> }
<ide>
<add> @Test
<add> public void testRelOperatorsBetween04() {
<add> evaluate("new java.math.BigDecimal('1') between {new java.math.BigDecimal('1'),new java.math.BigDecimal('5')}", "true", Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') between {new java.math.BigDecimal('1'),new java.math.BigDecimal('5')}", "true", Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') between {new java.math.BigDecimal('1'),new java.math.BigDecimal('5')}", "true", Boolean.class);
<add> evaluate("new java.math.BigDecimal('8') between {new java.math.BigDecimal('1'),new java.math.BigDecimal('5')}", "false", Boolean.class);
<add> }
<add>
<ide> @Test
<ide> public void testRelOperatorsBetweenErrors02() {
<ide> evaluateAndCheckError("'abc' between {5,7}", SpelMessage.NOT_COMPARABLE, 6);
<ide><path>spring-expression/src/test/java/org/springframework/expression/spel/OperatorTests.java
<ide> /*
<del> * Copyright 2002-2012 the original author or authors.
<add> * Copyright 2002-2013 the original author or authors.
<ide> *
<ide> * Licensed under the Apache License, Version 2.0 (the "License");
<ide> * you may not use this file except in compliance with the License.
<ide> package org.springframework.expression.spel;
<ide>
<ide> import static org.junit.Assert.assertEquals;
<add>import java.math.BigDecimal;
<ide>
<ide> import org.junit.Test;
<ide> import org.springframework.expression.spel.ast.Operator;
<ide> * Tests the evaluation of expressions using relational operators.
<ide> *
<ide> * @author Andy Clement
<add> * @author Giovanni Dall'Oglio Risso
<ide> */
<ide> public class OperatorTests extends ExpressionTestCase {
<ide>
<ide> public void testRealLiteral() {
<ide>
<ide> @Test
<ide> public void testLessThan() {
<add>
<add> evaluate("5 < 5", false, Boolean.class);
<ide> evaluate("3 < 5", true, Boolean.class);
<ide> evaluate("5 < 3", false, Boolean.class);
<ide> evaluate("3L < 5L", true, Boolean.class);
<ide> public void testLessThan() {
<ide> evaluate("5.0d < 3.0d", false, Boolean.class);
<ide> evaluate("'abc' < 'def'",true,Boolean.class);
<ide> evaluate("'def' < 'abc'",false,Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') < new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') < new java.math.BigDecimal('3')", false, Boolean.class);
<add> evaluate("3 < new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') < 5", true, Boolean.class);
<add> evaluate("3L < new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("3.0d < new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("3L < new java.math.BigDecimal('3.1')", true, Boolean.class);
<add> evaluate("3.0d < new java.math.BigDecimal('3.1')", true, Boolean.class);
<add> evaluate("3.0d < new java.math.BigDecimal('3.0')", false, Boolean.class);
<ide>
<ide> evaluate("3 lt 5", true, Boolean.class);
<ide> evaluate("5 lt 3", false, Boolean.class);
<ide> public void testLessThan() {
<ide> evaluate("5.0d Lt 3.0d", false, Boolean.class);
<ide> evaluate("'abc' LT 'def'",true,Boolean.class);
<ide> evaluate("'def' lt 'abc'",false,Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') lt new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') lt new java.math.BigDecimal('3')", false, Boolean.class);
<add> evaluate("3 lt new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') lt 5", true, Boolean.class);
<add> evaluate("3L lt new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("3.0d lt new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("3L lt new java.math.BigDecimal('3.1')", true, Boolean.class);
<add> evaluate("3.0d lt new java.math.BigDecimal('3.1')", true, Boolean.class);
<add> evaluate("3.0d lt new java.math.BigDecimal('3.0')", false, Boolean.class);
<ide> }
<ide>
<ide> @Test
<ide> public void testLessThanOrEqual() {
<ide> evaluate("'abc' <= 'def'",true,Boolean.class);
<ide> evaluate("'def' <= 'abc'",false,Boolean.class);
<ide> evaluate("'abc' <= 'abc'",true,Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') <= new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') <= new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') <= new java.math.BigDecimal('3')", false, Boolean.class);
<add> evaluate("3 <= new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') <= 5", true, Boolean.class);
<add> evaluate("3L <= new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("3.0d <= new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("3L <= new java.math.BigDecimal('3.1')", true, Boolean.class);
<add> evaluate("3.0d <= new java.math.BigDecimal('3.1')", true, Boolean.class);
<add> evaluate("3.0d <= new java.math.BigDecimal('3.0')", true, Boolean.class);
<ide>
<ide> evaluate("3 le 5", true, Boolean.class);
<ide> evaluate("5 le 3", false, Boolean.class);
<ide> public void testLessThanOrEqual() {
<ide> evaluate("'abc' Le 'def'",true,Boolean.class);
<ide> evaluate("'def' LE 'abc'",false,Boolean.class);
<ide> evaluate("'abc' le 'abc'",true,Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') le new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') le new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') le new java.math.BigDecimal('3')", false, Boolean.class);
<add> evaluate("3 le new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') le 5", true, Boolean.class);
<add> evaluate("3L le new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("3.0d le new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("3L le new java.math.BigDecimal('3.1')", true, Boolean.class);
<add> evaluate("3.0d le new java.math.BigDecimal('3.1')", true, Boolean.class);
<add> evaluate("3.0d le new java.math.BigDecimal('3.0')", true, Boolean.class);
<ide> }
<ide>
<ide> @Test
<ide> public void testEqual() {
<ide> evaluate("3.0f == 5.0f", false, Boolean.class);
<ide> evaluate("3.0f == 3.0f", true, Boolean.class);
<ide> evaluate("'abc' == null", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') == new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') == new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') == new java.math.BigDecimal('3')", false, Boolean.class);
<add> evaluate("3 == new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') == 5", false, Boolean.class);
<add> evaluate("3L == new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("3.0d == new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("3L == new java.math.BigDecimal('3.1')", false, Boolean.class);
<add> evaluate("3.0d == new java.math.BigDecimal('3.1')", false, Boolean.class);
<add> evaluate("3.0d == new java.math.BigDecimal('3.0')", true, Boolean.class);
<ide>
<ide> evaluate("3 eq 5", false, Boolean.class);
<ide> evaluate("5 eQ 3", false, Boolean.class);
<ide> evaluate("6 Eq 6", true, Boolean.class);
<ide> evaluate("3.0f eq 5.0f", false, Boolean.class);
<ide> evaluate("3.0f EQ 3.0f", true, Boolean.class);
<ide> evaluate("'abc' EQ null", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') eq new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') eq new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') eq new java.math.BigDecimal('3')", false, Boolean.class);
<add> evaluate("3 eq new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') eq 5", false, Boolean.class);
<add> evaluate("3L eq new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("3.0d eq new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("3L eq new java.math.BigDecimal('3.1')", false, Boolean.class);
<add> evaluate("3.0d eq new java.math.BigDecimal('3.1')", false, Boolean.class);
<add> evaluate("3.0d eq new java.math.BigDecimal('3.0')", true, Boolean.class);
<ide> }
<ide>
<ide> @Test
<ide> public void testNotEqual() {
<ide> evaluate("6 != 6", false, Boolean.class);
<ide> evaluate("3.0f != 5.0f", true, Boolean.class);
<ide> evaluate("3.0f != 3.0f", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') != new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') != new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') != new java.math.BigDecimal('3')", true, Boolean.class);
<add> evaluate("3 != new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') != 5", true, Boolean.class);
<add> evaluate("3L != new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("3.0d != new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("3L != new java.math.BigDecimal('3.1')", true, Boolean.class);
<add> evaluate("3.0d != new java.math.BigDecimal('3.1')", true, Boolean.class);
<add> evaluate("3.0d != new java.math.BigDecimal('3.0')", false, Boolean.class);
<ide>
<ide> evaluate("3 ne 5", true, Boolean.class);
<ide> evaluate("5 nE 3", true, Boolean.class);
<ide> evaluate("6 Ne 6", false, Boolean.class);
<ide> evaluate("3.0f NE 5.0f", true, Boolean.class);
<ide> evaluate("3.0f ne 3.0f", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') ne new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') ne new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') ne new java.math.BigDecimal('3')", true, Boolean.class);
<add> evaluate("3 ne new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') ne 5", true, Boolean.class);
<add> evaluate("3L ne new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("3.0d ne new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("3L ne new java.math.BigDecimal('3.1')", true, Boolean.class);
<add> evaluate("3.0d ne new java.math.BigDecimal('3.1')", true, Boolean.class);
<add> evaluate("3.0d ne new java.math.BigDecimal('3.0')", false, Boolean.class);
<ide> }
<ide>
<ide> @Test
<ide> public void testGreaterThanOrEqual() {
<ide> evaluate("'abc' >= 'def'",false,Boolean.class);
<ide> evaluate("'def' >= 'abc'",true,Boolean.class);
<ide> evaluate("'abc' >= 'abc'",true,Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') >= new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') >= new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') >= new java.math.BigDecimal('3')", true, Boolean.class);
<add> evaluate("3 >= new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') >= 5", false, Boolean.class);
<add> evaluate("3L >= new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("3.0d >= new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("3L >= new java.math.BigDecimal('3.1')", false, Boolean.class);
<add> evaluate("3.0d >= new java.math.BigDecimal('3.1')", false, Boolean.class);
<add> evaluate("3.0d >= new java.math.BigDecimal('3.0')", true, Boolean.class);
<ide>
<ide> evaluate("3 GE 5", false, Boolean.class);
<ide> evaluate("5 gE 3", true, Boolean.class);
<ide> evaluate("6 Ge 6", true, Boolean.class);
<ide> evaluate("3L ge 5L", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') ge new java.math.BigDecimal('5')", true, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') ge new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') ge new java.math.BigDecimal('3')", true, Boolean.class);
<add> evaluate("3 ge new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') ge 5", false, Boolean.class);
<add> evaluate("3L ge new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("3.0d ge new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("3L ge new java.math.BigDecimal('3.1')", false, Boolean.class);
<add> evaluate("3.0d ge new java.math.BigDecimal('3.1')", false, Boolean.class);
<add> evaluate("3.0d ge new java.math.BigDecimal('3.0')", true, Boolean.class);
<ide> }
<ide>
<ide> @Test
<ide> public void testGreaterThan() {
<ide> evaluate("5.0d > 3.0d", true, Boolean.class);
<ide> evaluate("'abc' > 'def'",false,Boolean.class);
<ide> evaluate("'def' > 'abc'",true,Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') > new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') > new java.math.BigDecimal('3')", true, Boolean.class);
<add> evaluate("3 > new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') > 5", false, Boolean.class);
<add> evaluate("3L > new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("3.0d > new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("3L > new java.math.BigDecimal('3.1')", false, Boolean.class);
<add> evaluate("3.0d > new java.math.BigDecimal('3.1')", false, Boolean.class);
<add> evaluate("3.0d > new java.math.BigDecimal('3.0')", false, Boolean.class);
<ide>
<ide> evaluate("3.0d gt 5.0d", false, Boolean.class);
<ide> evaluate("5.0d gT 3.0d", true, Boolean.class);
<ide> evaluate("'abc' Gt 'def'",false,Boolean.class);
<ide> evaluate("'def' GT 'abc'",true,Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') gt new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('5') gt new java.math.BigDecimal('3')", true, Boolean.class);
<add> evaluate("3 gt new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("new java.math.BigDecimal('3') gt 5", false, Boolean.class);
<add> evaluate("3L gt new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("3.0d gt new java.math.BigDecimal('5')", false, Boolean.class);
<add> evaluate("3L gt new java.math.BigDecimal('3.1')", false, Boolean.class);
<add> evaluate("3.0d gt new java.math.BigDecimal('3.1')", false, Boolean.class);
<add> evaluate("3.0d gt new java.math.BigDecimal('3.0')", false, Boolean.class);
<ide> }
<ide>
<ide> @Test
<ide> public void testMultiplyDoubleDoubleGivesDouble() {
<ide> evaluate("3.0d * 5.0d", 15.0d, Double.class);
<ide> }
<ide>
<add> @Test
<add> public void testMixedOperandsBigDecimal() {
<add> evaluate("3 * new java.math.BigDecimal('5')", new BigDecimal("15"), BigDecimal.class);
<add> evaluate("3L * new java.math.BigDecimal('5')", new BigDecimal("15"), BigDecimal.class);
<add> evaluate("3.0d * new java.math.BigDecimal('5')", new BigDecimal("15.0"), BigDecimal.class);
<add>
<add> evaluate("3 + new java.math.BigDecimal('5')", new BigDecimal("8"), BigDecimal.class);
<add> evaluate("3L + new java.math.BigDecimal('5')", new BigDecimal("8"), BigDecimal.class);
<add> evaluate("3.0d + new java.math.BigDecimal('5')", new BigDecimal("8.0"), BigDecimal.class);
<add>
<add> evaluate("3 - new java.math.BigDecimal('5')", new BigDecimal("-2"), BigDecimal.class);
<add> evaluate("3L - new java.math.BigDecimal('5')", new BigDecimal("-2"), BigDecimal.class);
<add> evaluate("3.0d - new java.math.BigDecimal('5')", new BigDecimal("-2.0"), BigDecimal.class);
<add>
<add> evaluate("3 / new java.math.BigDecimal('5')", new BigDecimal("1"), BigDecimal.class);
<add> evaluate("3 / new java.math.BigDecimal('5.0')", new BigDecimal("0.6"), BigDecimal.class);
<add> evaluate("3 / new java.math.BigDecimal('5.00')", new BigDecimal("0.60"), BigDecimal.class);
<add> evaluate("3L / new java.math.BigDecimal('5.0')", new BigDecimal("0.6"), BigDecimal.class);
<add> evaluate("3.0d / new java.math.BigDecimal('5.0')", new BigDecimal("0.6"), BigDecimal.class);
<add>
<add> evaluate("5 % new java.math.BigDecimal('3')", new BigDecimal("2"), BigDecimal.class);
<add> evaluate("3 % new java.math.BigDecimal('5')", new BigDecimal("3"), BigDecimal.class);
<add> evaluate("3L % new java.math.BigDecimal('5')", new BigDecimal("3"), BigDecimal.class);
<add> evaluate("3.0d % new java.math.BigDecimal('5')", new BigDecimal("3.0"), BigDecimal.class);
<add> }
<add>
<ide> @Test
<ide> public void testMathOperatorAdd02() {
<ide> evaluate("'hello' + ' ' + 'world'", "hello world", String.class);
<ide> public void testPlus() throws Exception {
<ide> evaluate("7 + 2", "9", Integer.class);
<ide> evaluate("3.0f + 5.0f", 8.0f, Float.class);
<ide> evaluate("3.0d + 5.0d", 8.0d, Double.class);
<add> evaluate("3 + new java.math.BigDecimal('5')", new BigDecimal("8"), BigDecimal.class);
<ide>
<ide> evaluate("'ab' + 2", "ab2", String.class);
<ide> evaluate("2 + 'a'", "2a", String.class);
<ide> public void testPlus() throws Exception {
<ide> evaluate("+5d",5d,Double.class);
<ide> evaluate("+5L",5L,Long.class);
<ide> evaluate("+5",5,Integer.class);
<add> evaluate("+new java.math.BigDecimal('5')", new BigDecimal("5"),BigDecimal.class);
<ide> evaluateAndCheckError("+'abc'",SpelMessage.OPERATOR_NOT_SUPPORTED_BETWEEN_TYPES);
<ide>
<ide> // string concatenation
<ide> public void testMinus() throws Exception {
<ide> evaluate("-5d",-5d,Double.class);
<ide> evaluate("-5L",-5L,Long.class);
<ide> evaluate("-5",-5,Integer.class);
<add> evaluate("-new java.math.BigDecimal('5')", new BigDecimal("-5"),BigDecimal.class);
<ide> evaluateAndCheckError("-'abc'",SpelMessage.OPERATOR_NOT_SUPPORTED_BETWEEN_TYPES);
<ide> }
<ide>
<ide> public void testModulus() {
<ide> evaluate("3L%2L",1L,Long.class);
<ide> evaluate("3.0f%2.0f",1f,Float.class);
<ide> evaluate("5.0d % 3.1d", 1.9d, Double.class);
<add> evaluate("new java.math.BigDecimal('5') % new java.math.BigDecimal('3')", new BigDecimal("2"), BigDecimal.class);
<add> evaluate("new java.math.BigDecimal('5') % 3", new BigDecimal("2"), BigDecimal.class);
<ide> evaluateAndCheckError("'abc'%'def'",SpelMessage.OPERATOR_NOT_SUPPORTED_BETWEEN_TYPES);
<ide> }
<ide>
<ide> public void testDivide() {
<ide> evaluate("4L/2L",2L,Long.class);
<ide> evaluate("3.0f div 5.0f", 0.6f, Float.class);
<ide> evaluate("4L DIV 2L",2L,Long.class);
<add> evaluate("new java.math.BigDecimal('3') / 5", new BigDecimal("1"), BigDecimal.class);
<add> evaluate("new java.math.BigDecimal('3.0') / 5", new BigDecimal("0.6"), BigDecimal.class);
<add> evaluate("new java.math.BigDecimal('3.00') / 5", new BigDecimal("0.60"), BigDecimal.class);
<add> evaluate("new java.math.BigDecimal('3.00') / new java.math.BigDecimal('5.0000')", new BigDecimal("0.6000"), BigDecimal.class);
<ide> evaluateAndCheckError("'abc'/'def'",SpelMessage.OPERATOR_NOT_SUPPORTED_BETWEEN_TYPES);
<ide> }
<ide>
<ide> public void testDoubles() {
<ide> evaluate("6.0d % 3.5d", 2.5d, Double.class);
<ide> }
<ide>
<add>
<add> @Test
<add> public void testBigDecimals() {
<add> evaluate("3 + new java.math.BigDecimal('5')", new BigDecimal("8"), BigDecimal.class);
<add> evaluate("3 - new java.math.BigDecimal('5')", new BigDecimal("-2"), BigDecimal.class);
<add> evaluate("3 * new java.math.BigDecimal('5')", new BigDecimal("15"), BigDecimal.class);
<add> evaluate("3 / new java.math.BigDecimal('5')", new BigDecimal("1"), BigDecimal.class);
<add> evaluate("5 % new java.math.BigDecimal('3')", new BigDecimal("2"), BigDecimal.class);
<add> evaluate("new java.math.BigDecimal('5') % 3", new BigDecimal("2"), BigDecimal.class);
<add> evaluate("new java.math.BigDecimal('5') ^ 3", new BigDecimal("125"), BigDecimal.class);
<add> }
<add>
<ide> @Test
<ide> public void testOperatorNames() throws Exception {
<ide> Operator node = getOperatorNode((SpelExpression)parser.parseExpression("1==3"));
<ide> public void testPower() {
<ide> evaluate("3.0d^2.0d",9.0d,Double.class);
<ide> evaluate("3L^2L",9L,Long.class);
<ide> evaluate("(2^32)^2",9223372036854775807L,Long.class);
<add> evaluate("new java.math.BigDecimal('5') ^ 3", new BigDecimal("125"), BigDecimal.class);
<ide> }
<ide>
<ide> @Test | 18 |
Python | Python | update the docstring for the return type | 3c194341b928da32817cca8756c2416284465d2b | <ide><path>keras/engine/compile_utils.py
<ide> def __call__(self,
<ide> regularization_losses: Additional losses to be added to the total loss.
<ide>
<ide> Returns:
<del> Tuple of `(total_loss, per_output_loss_list)`
<add> The total loss as a `tf.Tensor`, or `None` if no loss results.
<ide> """
<ide> y_true = self._conform_to_outputs(y_pred, y_true)
<ide> sample_weight = self._conform_to_outputs(y_pred, sample_weight)
<ide><path>keras/engine/compile_utils_test.py
<ide> def test_single_loss(self):
<ide>
<ide> self.assertTrue(loss_container._built)
<ide> self.assertLen(loss_container._losses, 1)
<add> self.assertIsInstance(total_loss, tf.Tensor)
<ide> self.assertEqual(total_loss.numpy(), 1.)
<ide> self.assertLen(loss_container.metrics, 1)
<ide>
<ide> def test_loss_dict(self):
<ide> total_loss = loss_container(y_t, y_p, sample_weight=sw)
<ide>
<ide> self.assertLen(loss_container._losses, 2)
<add> self.assertIsInstance(total_loss, tf.Tensor)
<ide> self.assertEqual(total_loss.numpy(), 0.25)
<ide> self.assertLen(loss_container.metrics, 3)
<ide>
<ide> def test_loss_dict_with_nones(self):
<ide>
<ide> total_loss = loss_container(y_t, y_p, sample_weight=sw)
<ide>
<add> self.assertIsInstance(total_loss, tf.Tensor)
<ide> self.assertEqual(total_loss.numpy(), 0.5)
<ide> self.assertLen(loss_container.metrics, 2)
<ide>
<ide> def test_nested_structure(self):
<ide> sw = tf.convert_to_tensor([0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
<ide>
<ide> total_loss = loss_container(y_t, y_p, sample_weight=sw)
<add> self.assertIsInstance(total_loss, tf.Tensor)
<ide> self.assertEqual(total_loss.numpy(), 0.75)
<ide> self.assertLen(loss_container.metrics, 3)
<ide>
<ide> def my_mae(labels, preds):
<ide>
<ide> loss_container = compile_utils.LossesContainer(my_mae)
<ide> total_loss = loss_container(y_t, y_p)
<add> self.assertIsInstance(total_loss, tf.Tensor)
<ide> self.assertEqual(total_loss.dtype, tf.float64)
<ide>
<ide> def test_loss_masking(self):
<ide> def call(self, y_true, y_pred):
<ide> tf.RaggedTensor.from_row_splits(v_t, [0, 2, 3]), 0)
<ide> y_p = tf.expand_dims(
<ide> tf.RaggedTensor.from_row_splits(v_p, [0, 2, 3]), 0)
<del> loss_container(y_t, y_p)
<add> total_loss = loss_container(y_t, y_p)
<ide>
<add> self.assertIsInstance(total_loss, tf.Tensor)
<ide> self.assertEqual(loss_container._losses[0].name, 'custom_loss_fn')
<ide>
<ide> | 2 |
PHP | PHP | improve cookie encryption | 594a3abdec383b55ce32a9e960263f55b41318e2 | <ide><path>src/Illuminate/Cookie/Middleware/EncryptCookies.php
<ide> protected function decrypt(Request $request)
<ide> }
<ide>
<ide> try {
<del> $request->cookies->set($key, $this->decryptCookie($key, $cookie));
<add> $value = $this->decryptCookie($key, $cookie);
<add>
<add> $request->cookies->set(
<add> $key, strpos($value, sha1($key).'|') !== 0 ? null : substr($value, 41)
<add> );
<ide> } catch (DecryptException $e) {
<ide> $request->cookies->set($key, null);
<ide> }
<ide> protected function encrypt(Response $response)
<ide> }
<ide>
<ide> $response->headers->setCookie($this->duplicate(
<del> $cookie, $this->encrypter->encrypt($cookie->getValue(), static::serialized($cookie->getName()))
<add> $cookie,
<add> $this->encrypter->encrypt(
<add> sha1($cookie->getName()).'|'.$cookie->getValue(),
<add> static::serialized($cookie->getName())
<add> )
<ide> ));
<ide> }
<ide> | 1 |
Text | Text | improve security section of readme.md | c3e75ae0ee97553f5f9c4150c936ae9d81fca558 | <ide><path>README.md
<ide> officially supported platforms.
<ide>
<ide> ## Security
<ide>
<del>All security bugs in Node.js are taken seriously and should be reported by
<del>emailing [email protected]. This will be delivered to a subset of the project
<del>team who handle security issues. Please don't disclose security bugs
<del>publicly until they have been handled by the security team.
<add>Security flaws in Node.js should be reported by emailing [email protected].
<add>Please do not disclose security bugs publicly until they have been handled by
<add>the security team.
<ide>
<del>Your email will be acknowledged within 24 hours, and you’ll receive a more
<add>Your email will be acknowledged within 24 hours, and you will receive a more
<ide> detailed response to your email within 48 hours indicating the next steps in
<ide> handling your report.
<ide>
<ide> There are no hard and fast rules to determine if a bug is worth reporting as
<del>a security issue. The general rule is any issue worth reporting
<del>must allow an attacker to compromise the confidentiality, integrity
<del>or availability of the Node.js application or its system for which the attacker
<del>does not already have the capability.
<add>a security issue. The general rule is an issue worth reporting should allow an
<add>attacker to compromise the confidentiality, integrity, or availability of the
<add>Node.js application or its system for which the attacker does not already have
<add>the capability.
<ide>
<ide> To illustrate the point, here are some examples of past issues and what the
<ide> Security Response Team thinks of them. When in doubt, however, please do send | 1 |
Javascript | Javascript | use long property names in share scope | 90b8056b1d95b949d74ab29faf0c23ba59d3977e | <ide><path>lib/sharing/ConsumeSharedRuntimeModule.js
<ide> class ConsumeSharedRuntimeModule extends RuntimeModule {
<ide> 'typeof console !== "undefined" && console.warn && console.warn(msg);',
<ide> "return 1;"
<ide> ])};`,
<del> "var v = scope[key].v;",
<add> "var v = scope[key].version;",
<ide> "if(!v) return versionConflict();",
<ide> "for(var i = 0; i < version.length; i++) {",
<ide> Template.indent([ | 1 |
Go | Go | add extra permission check in removal test | d6cbeee470105df403b7ae716c923fd11003b67c | <ide><path>integration/image/remove_unix_test.go
<ide> import (
<ide> "io/ioutil"
<ide> "os"
<ide> "strconv"
<add> "strings"
<ide> "syscall"
<ide> "testing"
<ide> "unsafe"
<ide> func TestRemoveImageGarbageCollector(t *testing.T) {
<ide> argp = uintptr(unsafe.Pointer(&attr))
<ide> _, _, errno = syscall.Syscall(syscall.SYS_IOCTL, file.Fd(), fsflags, argp)
<ide> assert.Equal(t, "errno 0", errno.Error())
<del> assert.ErrorContains(t, err, "permission denied")
<add> assert.Assert(t, err != nil)
<add> errStr := err.Error()
<add> if !(strings.Contains(errStr, "permission denied") || strings.Contains(errStr, "operation not permitted")) {
<add> t.Errorf("ImageRemove error not an permission error %s", errStr)
<add> }
<ide>
<ide> // Verify that layer remaining on disk
<ide> dir, _ := os.Stat(data["UpperDir"]) | 1 |
Python | Python | fix failing tests | e2ae2f74f0bae47033da7444cc78a736fadbf5cd | <ide><path>libcloud/dns/base.py
<ide> def _get_bind_record_line(self, record):
<ide>
<ide> if record.type in [RecordType.MX, RecordType.SRV]:
<ide> priority = str(record.extra['priority'])
<del> parts = [name, ttl, 'IN', record.type, priority, data]
<add> parts = [name, ttl, 'IN', str(record.type), priority, data]
<ide> else:
<del> parts = [name, ttl, 'IN', record.type, data]
<add> parts = [name, ttl, 'IN', str(record.type), data]
<ide>
<ide> line = '\t'.join(parts)
<ide> return line | 1 |
Javascript | Javascript | add removed vm-browserify hint | fe393fbb4e2994dff479a7b12cafad95bf20691d | <ide><path>lib/ModuleNotFoundError.js
<ide> const previouslyPolyfilledBuiltinModules = {
<ide> tty: "tty-browserify",
<ide> url: "url",
<ide> util: "util",
<add> vm: "vm-browserify",
<ide> zlib: "browserify-zlib"
<ide> };
<ide> | 1 |
Go | Go | remove unused functions | 236a125c3afdee30b739399aaea263c37cb28b04 | <ide><path>cli/required.go
<ide> func NoArgs(cmd *cobra.Command, args []string) error {
<ide> cmd.Short,
<ide> )
<ide> }
<del>
<del>// RequiresMinArgs returns an error if there is not at least min args
<del>func RequiresMinArgs(min int) cobra.PositionalArgs {
<del> return func(cmd *cobra.Command, args []string) error {
<del> if len(args) >= min {
<del> return nil
<del> }
<del> return errors.Errorf(
<del> "\"%s\" requires at least %d argument(s).\nSee '%s --help'.\n\nUsage: %s\n\n%s",
<del> cmd.CommandPath(),
<del> min,
<del> cmd.CommandPath(),
<del> cmd.UseLine(),
<del> cmd.Short,
<del> )
<del> }
<del>}
<del>
<del>// RequiresMaxArgs returns an error if there is not at most max args
<del>func RequiresMaxArgs(max int) cobra.PositionalArgs {
<del> return func(cmd *cobra.Command, args []string) error {
<del> if len(args) <= max {
<del> return nil
<del> }
<del> return errors.Errorf(
<del> "\"%s\" requires at most %d argument(s).\nSee '%s --help'.\n\nUsage: %s\n\n%s",
<del> cmd.CommandPath(),
<del> max,
<del> cmd.CommandPath(),
<del> cmd.UseLine(),
<del> cmd.Short,
<del> )
<del> }
<del>}
<del>
<del>// RequiresRangeArgs returns an error if there is not at least min args and at most max args
<del>func RequiresRangeArgs(min int, max int) cobra.PositionalArgs {
<del> return func(cmd *cobra.Command, args []string) error {
<del> if len(args) >= min && len(args) <= max {
<del> return nil
<del> }
<del> return errors.Errorf(
<del> "\"%s\" requires at least %d and at most %d argument(s).\nSee '%s --help'.\n\nUsage: %s\n\n%s",
<del> cmd.CommandPath(),
<del> min,
<del> max,
<del> cmd.CommandPath(),
<del> cmd.UseLine(),
<del> cmd.Short,
<del> )
<del> }
<del>}
<del>
<del>// ExactArgs returns an error if there is not the exact number of args
<del>func ExactArgs(number int) cobra.PositionalArgs {
<del> return func(cmd *cobra.Command, args []string) error {
<del> if len(args) == number {
<del> return nil
<del> }
<del> return errors.Errorf(
<del> "\"%s\" requires exactly %d argument(s).\nSee '%s --help'.\n\nUsage: %s\n\n%s",
<del> cmd.CommandPath(),
<del> number,
<del> cmd.CommandPath(),
<del> cmd.UseLine(),
<del> cmd.Short,
<del> )
<del> }
<del>} | 1 |
Javascript | Javascript | remove plain object warning | b2297ae6c3117ca9b3e15aedaf73d9187eb88e6c | <ide><path>src/isomorphic/classic/element/ReactElement.js
<ide> ReactElement.createElement = function(type, config, children) {
<ide> var source = null;
<ide>
<ide> if (config != null) {
<del> if (__DEV__) {
<del> warning(
<del> /* eslint-disable no-proto */
<del> config.__proto__ == null || config.__proto__ === Object.prototype,
<del> /* eslint-enable no-proto */
<del> 'React.createElement(...): Expected props argument to be a plain object. ' +
<del> 'Properties defined in its prototype chain will be ignored.'
<del> );
<del> }
<del>
<ide> if (hasValidRef(config)) {
<ide> ref = config.ref;
<ide> }
<ide> ReactElement.cloneElement = function(element, config, children) {
<ide> var owner = element._owner;
<ide>
<ide> if (config != null) {
<del> if (__DEV__) {
<del> warning(
<del> /* eslint-disable no-proto */
<del> config.__proto__ == null || config.__proto__ === Object.prototype,
<del> /* eslint-enable no-proto */
<del> 'React.cloneElement(...): Expected props argument to be a plain object. ' +
<del> 'Properties defined in its prototype chain will be ignored.'
<del> );
<del> }
<del>
<ide> if (hasValidRef(config)) {
<ide> // Silently steal the ref from the parent.
<ide> ref = config.ref;
<ide><path>src/isomorphic/classic/element/__tests__/ReactElement-test.js
<ide> describe('ReactElement', () => {
<ide> expect(element.props.foo).toBe(1);
<ide> });
<ide>
<del> it('warns if the config object inherits from any type other than Object', () => {
<del> spyOn(console, 'error');
<del> React.createElement('div', {foo: 1});
<del> expect(console.error).not.toHaveBeenCalled();
<del> React.createElement('div', Object.create({foo: 1}));
<del> expect(console.error.calls.count()).toBe(1);
<del> expect(console.error.calls.argsFor(0)[0]).toContain(
<del> 'React.createElement(...): Expected props argument to be a plain object. ' +
<del> 'Properties defined in its prototype chain will be ignored.'
<del> );
<del> });
<del>
<ide> it('extracts key and ref from the config', () => {
<ide> var element = React.createFactory(ComponentClass)({
<ide> key: '12',
<ide><path>src/isomorphic/classic/element/__tests__/ReactElementClone-test.js
<ide> describe('ReactElementClone', () => {
<ide> expect(ReactDOM.findDOMNode(component).childNodes[0].className).toBe('xyz');
<ide> });
<ide>
<del> it('should warn if the config object inherits from any type other than Object', () => {
<del> spyOn(console, 'error');
<del> React.cloneElement('div', {foo: 1});
<del> expect(console.error).not.toHaveBeenCalled();
<del> React.cloneElement('div', Object.create({foo: 1}));
<del> expect(console.error.calls.count()).toBe(1);
<del> expect(console.error.calls.argsFor(0)[0]).toContain(
<del> 'React.cloneElement(...): Expected props argument to be a plain object. ' +
<del> 'Properties defined in its prototype chain will be ignored.'
<del> );
<del> });
<del>
<ide> it('does not fail if config has no prototype', () => {
<ide> var config = Object.create(null, {foo: {value: 1, enumerable: true}});
<ide> React.cloneElement(<div />, config); | 3 |
Java | Java | add protected method for required requestbody | e4539d9f4003bee0f3cd31dd70b87a32ffb95884 | <ide><path>spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/RequestResponseBodyMethodProcessor.java
<ide> /*
<del> * Copyright 2002-2015 the original author or authors.
<add> * Copyright 2002-2016 the original author or authors.
<ide> *
<ide> * Licensed under the Apache License, Version 2.0 (the "License");
<ide> * you may not use this file except in compliance with the License.
<ide> protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, Meth
<ide>
<ide> Object arg = readWithMessageConverters(inputMessage, methodParam, paramType);
<ide> if (arg == null) {
<del> if (methodParam.getParameterAnnotation(RequestBody.class).required()) {
<add> if (checkRequired(methodParam)) {
<ide> throw new HttpMessageNotReadableException("Required request body is missing: " +
<ide> methodParam.getMethod().toGenericString());
<ide> }
<ide> }
<ide> return arg;
<ide> }
<ide>
<add> protected boolean checkRequired(MethodParameter methodParam) {
<add> return methodParam.getParameterAnnotation(RequestBody.class).required();
<add> }
<add>
<ide> @Override
<ide> public void handleReturnValue(Object returnValue, MethodParameter returnType,
<ide> ModelAndViewContainer mavContainer, NativeWebRequest webRequest) | 1 |
Javascript | Javascript | improve flagincludedchunksplugin performance | 4dabf3075fd396c6d0fb7e9a93c2d4a69ace9101 | <ide><path>lib/optimize/FlagIncludedChunksPlugin.js
<ide> class FlagIncludedChunksPlugin {
<ide> compilation.hooks.optimizeChunkIds.tap(
<ide> "FlagIncludedChunksPlugin",
<ide> chunks => {
<add> // prepare two bit integers for each module
<add> // 2^31 is the max number represented as SMI in v8
<add> // we want the bits distributed this way:
<add> // the bit 2^31 is pretty rar and only one module should get it
<add> // so it has a probability of 1 / modulesCount
<add> // the first bit (2^0) is the easiest and every module could get it
<add> // if it doesn't get a better bit
<add> // from bit 2^n to 2^(n+1) there is a probability of p
<add> // so 1 / modulesCount == p^31
<add> // <=> p = sqrt31(1 / modulesCount)
<add> // so we use a modulo of 1 / sqrt31(1 / modulesCount)
<add> const moduleBits = new WeakMap();
<add> const modulesCount = compilation.modules.length;
<add>
<add> // precalculate the modulo values for each bit
<add> const modulo = 1 / Math.pow(1 / modulesCount, 1 / 31);
<add> const modulos = Array.from(
<add> { length: 31 },
<add> (x, i) => Math.pow(modulo, i) | 0
<add> );
<add>
<add> // iterate all modules to generate bit values
<add> let i = 0;
<add> for (const module of compilation.modules) {
<add> let bit = 30;
<add> while (i % modulos[bit] !== 0) {
<add> bit--;
<add> }
<add> moduleBits.set(module, 1 << bit);
<add> i++;
<add> }
<add>
<add> // interate all chunks to generate bitmaps
<add> const chunkModulesHash = new WeakMap();
<add> for (const chunk of chunks) {
<add> let hash = 0;
<add> for (const module of chunk.modulesIterable) {
<add> hash |= moduleBits.get(module);
<add> }
<add> chunkModulesHash.set(chunk, hash);
<add> }
<add>
<ide> for (const chunkA of chunks) {
<del> loopB: for (const chunkB of chunks) {
<add> const chunkAHash = chunkModulesHash.get(chunkA);
<add> const chunkAModulesCount = chunkA.getNumberOfModules();
<add> if (chunkAModulesCount === 0) continue;
<add> let bestModule = undefined;
<add> for (const module of chunkA.modulesIterable) {
<add> if (
<add> bestModule === undefined ||
<add> bestModule.getNumberOfChunks() > module.getNumberOfChunks()
<add> )
<add> bestModule = module;
<add> }
<add> loopB: for (const chunkB of bestModule.chunksIterable) {
<ide> // as we iterate the same iterables twice
<ide> // skip if we find ourselves
<del> if (chunkA === chunkB) continue loopB;
<add> if (chunkA === chunkB) continue;
<add>
<add> const chunkBModulesCount = chunkB.getNumberOfModules();
<add>
<add> // ids for empty chunks are not included
<add> if (chunkBModulesCount === 0) continue;
<ide>
<ide> // instead of swapping A and B just bail
<ide> // as we loop twice the current A will be B and B then A
<del> if (chunkA.getNumberOfModules() < chunkB.getNumberOfModules())
<del> continue loopB;
<add> if (chunkAModulesCount > chunkBModulesCount) continue;
<add>
<add> // is chunkA in chunkB?
<ide>
<del> if (chunkB.getNumberOfModules() === 0) continue loopB;
<add> // we do a cheap check for the hash value
<add> const chunkBHash = chunkModulesHash.get(chunkB);
<add> if ((chunkBHash & chunkAHash) !== chunkAHash) continue;
<ide>
<del> // is chunkB in chunkA?
<del> for (const m of chunkB.modulesIterable) {
<del> if (!chunkA.containsModule(m)) continue loopB;
<add> // compare all modules
<add> for (const m of chunkA.modulesIterable) {
<add> if (!chunkB.containsModule(m)) continue loopB;
<ide> }
<del> chunkA.ids.push(chunkB.id);
<add> chunkB.ids.push(chunkA.id);
<ide> }
<ide> }
<ide> } | 1 |
Ruby | Ruby | add quiet flags if not verbose | 9bd216725798148a28c0c6fa5422ad12148db799 | <ide><path>Library/Homebrew/unpack_strategy.rb
<ide> def self.can_extract?(path:, magic_number:)
<ide> private
<ide>
<ide> def extract_to_dir(unpack_dir, basename:, verbose:)
<del> safe_system "unzip", "-qq", path, "-d", unpack_dir
<add> quiet_flags = verbose ? [] : ["-qq"]
<add> safe_system "unzip", *quiet_flags, path, "-d", unpack_dir
<ide> end
<ide> end
<ide>
<ide> def self.can_extract?(path:, magic_number:)
<ide>
<ide> def extract_to_dir(unpack_dir, basename:, verbose:)
<ide> FileUtils.cp path, unpack_dir/basename, preserve: true
<del> safe_system Formula["xz"].opt_bin/"unxz", "-q", "-T0", unpack_dir/basename
<add> quiet_flags = verbose ? [] : ["-q"]
<add> safe_system Formula["xz"].opt_bin/"unxz", *quiet_flags, "-T0", unpack_dir/basename
<ide> extract_nested_tar(unpack_dir)
<ide> end
<ide>
<ide> def self.can_extract?(path:, magic_number:)
<ide>
<ide> def extract_to_dir(unpack_dir, basename:, verbose:)
<ide> FileUtils.cp path, unpack_dir/basename, preserve: true
<del> safe_system "bunzip2", "-q", unpack_dir/basename
<add> quiet_flags = verbose ? [] : ["-q"]
<add> safe_system "bunzip2", *quiet_flags, unpack_dir/basename
<ide> end
<ide> end
<ide>
<ide> def self.can_extract?(path:, magic_number:)
<ide>
<ide> def extract_to_dir(unpack_dir, basename:, verbose:)
<ide> FileUtils.cp path, unpack_dir/basename, preserve: true
<del> safe_system "gunzip", "-q", "-N", unpack_dir/basename
<add> quiet_flags = verbose ? [] : ["-q"]
<add> safe_system "gunzip", *quiet_flags, "-N", unpack_dir/basename
<ide> end
<ide> end
<ide>
<ide> def self.can_extract?(path:, magic_number:)
<ide>
<ide> def extract_to_dir(unpack_dir, basename:, verbose:)
<ide> FileUtils.cp path, unpack_dir/basename, preserve: true
<del> safe_system Formula["lzip"].opt_bin/"lzip", "-d", "-q", unpack_dir/basename
<add> quiet_flags = verbose ? [] : ["-q"]
<add> safe_system Formula["lzip"].opt_bin/"lzip", "-d", *quiet_flags, unpack_dir/basename
<ide> end
<ide> end
<ide> | 1 |
Python | Python | fix failures with recent moto library 2.2.15 | 49b7e751eb3cb512d138a06237116c3aec6c4290 | <ide><path>setup.py
<ide> def write_version(filename: str = os.path.join(*[my_dir, "airflow", "git_version
<ide> 'jira',
<ide> 'jsondiff',
<ide> 'mongomock',
<del> 'moto~=2.2, >=2.2.7',
<add> 'moto~=2.2, >=2.2.12',
<ide> 'mypy==0.770',
<ide> 'parameterized',
<ide> 'paramiko',
<ide><path>tests/providers/amazon/aws/hooks/test_cloud_formation.py
<ide>
<ide> try:
<ide> from moto import mock_cloudformation
<del> from moto.ec2.models import NetworkInterface as some_model
<ide> except ImportError:
<ide> mock_cloudformation = None
<ide>
<ide> def create_stack(self, stack_name):
<ide> {
<ide> 'Resources': {
<ide> "myResource": {
<del> "Type": some_model.cloudformation_type(),
<del> "Properties": {"myProperty": "myPropertyValue"},
<add> "Type": "AWS::EC2::VPC",
<add> "Properties": {
<add> "CidrBlock": {"Ref": "VPCCidr"},
<add> "Tags": [{"Key": "Name", "Value": "Primary_CF_VPC"}],
<add> },
<ide> }
<del> }
<add> },
<add> "Parameters": {
<add> "VPCCidr": {
<add> "Type": "String",
<add> "Default": "10.0.0.0/16",
<add> "Description": "Enter the CIDR block for the VPC. Default is 10.0.0.0/16.",
<add> }
<add> },
<ide> }
<ide> )
<ide>
<ide> def create_stack(self, stack_name):
<ide> params={
<ide> 'TimeoutInMinutes': timeout,
<ide> 'TemplateBody': template_body,
<del> 'Parameters': [{'ParameterKey': 'myParam', 'ParameterValue': 'myParamValue'}],
<add> 'Parameters': [{'ParameterKey': "VPCCidr", 'ParameterValue': '10.0.0.0/16'}],
<ide> },
<ide> )
<ide>
<ide><path>tests/providers/amazon/aws/hooks/test_logs.py
<ide> # specific language governing permissions and limitations
<ide> # under the License.
<ide> #
<del>
<add>import time
<ide> import unittest
<ide>
<ide> from airflow.providers.amazon.aws.hooks.logs import AwsLogsHook
<ide> def test_get_log_events(self):
<ide> conn.create_log_group(logGroupName=log_group_name)
<ide> conn.create_log_stream(logGroupName=log_group_name, logStreamName=log_stream_name)
<ide>
<del> input_events = [{'timestamp': 1, 'message': 'Test Message 1'}]
<add> input_events = [{'timestamp': int(time.time()) * 1000, 'message': 'Test Message 1'}]
<ide>
<ide> conn.put_log_events(
<ide> logGroupName=log_group_name, logStreamName=log_stream_name, logEvents=input_events
<ide><path>tests/providers/amazon/aws/log/test_cloudwatch_task_handler.py
<ide> # KIND, either express or implied. See the License for the
<ide> # specific language governing permissions and limitations
<ide> # under the License.
<del>
<add>import time
<ide> import unittest
<add>from datetime import datetime as dt
<ide> from unittest import mock
<ide> from unittest.mock import ANY, call
<ide>
<ide> mock_logs = None
<ide>
<ide>
<add>def get_time_str(time_in_milliseconds):
<add> dt_time = dt.utcfromtimestamp(time_in_milliseconds / 1000.0)
<add> return dt_time.strftime("%Y-%m-%d %H:%M:%S,000")
<add>
<add>
<ide> @unittest.skipIf(mock_logs is None, "Skipping test because moto.mock_logs is not available")
<ide> @mock_logs
<ide> class TestCloudwatchTaskHandler(unittest.TestCase):
<ide> def test_write(self):
<ide>
<ide> def test_event_to_str(self):
<ide> handler = self.cloudwatch_task_handler
<add> current_time = int(time.time()) * 1000
<ide> events = [
<del> {'timestamp': 1617400267123, 'message': 'First'},
<del> {'timestamp': 1617400367456, 'message': 'Second'},
<del> {'timestamp': 1617400467789, 'message': 'Third'},
<add> {'timestamp': current_time - 2000, 'message': 'First'},
<add> {'timestamp': current_time - 1000, 'message': 'Second'},
<add> {'timestamp': current_time, 'message': 'Third'},
<ide> ]
<ide> assert [handler._event_to_str(event) for event in events] == (
<ide> [
<del> '[2021-04-02 21:51:07,123] First',
<del> '[2021-04-02 21:52:47,456] Second',
<del> '[2021-04-02 21:54:27,789] Third',
<add> f'[{get_time_str(current_time-2000)}] First',
<add> f'[{get_time_str(current_time-1000)}] Second',
<add> f'[{get_time_str(current_time)}] Third',
<ide> ]
<ide> )
<ide>
<ide> def test_read(self):
<ide> # CloudWatch events must be ordered chronologically otherwise
<ide> # boto3 put_log_event API throws InvalidParameterException
<ide> # (moto does not throw this exception)
<add> current_time = int(time.time()) * 1000
<ide> generate_log_events(
<ide> self.conn,
<ide> self.remote_log_group,
<ide> self.remote_log_stream,
<ide> [
<del> {'timestamp': 1617400267123, 'message': 'First'},
<del> {'timestamp': 1617400367456, 'message': 'Second'},
<del> {'timestamp': 1617400467789, 'message': 'Third'},
<add> {'timestamp': current_time - 2000, 'message': 'First'},
<add> {'timestamp': current_time - 1000, 'message': 'Second'},
<add> {'timestamp': current_time, 'message': 'Third'},
<ide> ],
<ide> )
<ide>
<ide> msg_template = '*** Reading remote log from Cloudwatch log_group: {} log_stream: {}.\n{}\n'
<ide> events = '\n'.join(
<ide> [
<del> '[2021-04-02 21:51:07,123] First',
<del> '[2021-04-02 21:52:47,456] Second',
<del> '[2021-04-02 21:54:27,789] Third',
<add> f'[{get_time_str(current_time-2000)}] First',
<add> f'[{get_time_str(current_time-1000)}] Second',
<add> f'[{get_time_str(current_time)}] Third',
<ide> ]
<ide> )
<ide> assert self.cloudwatch_task_handler.read(self.ti) == ( | 4 |
Go | Go | add test for links in volumes | a57eee2229c2f0c53c32372587fcc2a8327044ea | <ide><path>integration-cli/docker_cli_build_test.go
<ide> func TestBuildAddBadLinks(t *testing.T) {
<ide> logDone("build - ADD must add files in container")
<ide> }
<ide>
<add>func TestBuildAddBadLinksVolume(t *testing.T) {
<add> const (
<add> dockerfileTemplate = `
<add> FROM busybox
<add> RUN ln -s /../../../../../../../../%s /x
<add> VOLUME /x
<add> ADD foo.txt /x/`
<add> targetFile = "foo.txt"
<add> )
<add> var (
<add> name = "test-link-absolute-volume"
<add> dockerfile = ""
<add> )
<add> defer deleteImages(name)
<add>
<add> tempDir, err := ioutil.TempDir("", "test-link-absolute-volume-temp-")
<add> if err != nil {
<add> t.Fatalf("failed to create temporary directory: %s", tempDir)
<add> }
<add> defer os.RemoveAll(tempDir)
<add>
<add> dockerfile = fmt.Sprintf(dockerfileTemplate, tempDir)
<add> nonExistingFile := filepath.Join(tempDir, targetFile)
<add>
<add> ctx, err := fakeContext(dockerfile, nil)
<add> if err != nil {
<add> t.Fatal(err)
<add> }
<add> defer ctx.Close()
<add> fooPath := filepath.Join(ctx.Dir, targetFile)
<add>
<add> foo, err := os.Create(fooPath)
<add> if err != nil {
<add> t.Fatal(err)
<add> }
<add> defer foo.Close()
<add>
<add> if _, err := foo.WriteString("test"); err != nil {
<add> t.Fatal(err)
<add> }
<add>
<add> if _, err := buildImageFromContext(name, ctx, true); err != nil {
<add> t.Fatal(err)
<add> }
<add>
<add> if _, err := os.Stat(nonExistingFile); err == nil || err != nil && !os.IsNotExist(err) {
<add> t.Fatalf("%s shouldn't have been written and it shouldn't exist", nonExistingFile)
<add> }
<add>
<add> logDone("build - ADD should add files in volume")
<add>}
<add>
<ide> // Issue #5270 - ensure we throw a better error than "unexpected EOF"
<ide> // when we can't access files in the context.
<ide> func TestBuildWithInaccessibleFilesInContext(t *testing.T) { | 1 |
Javascript | Javascript | update material properties for point clouds | d33553080ed90db6ebb59da4f30c094f6ea8fd34 | <ide><path>examples/jsm/loaders/3DMLoader.js
<ide> Rhino3dmLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
<ide> case 'PointSet':
<ide>
<ide> var geometry = loader.parse( obj.geometry );
<del> var _color = attributes.drawColor;
<del> var color = new Color( _color.r / 255.0, _color.g / 255.0, _color.b / 255.0 );
<del> var material = new PointsMaterial( { color: color, sizeAttenuation: false, size: 2 } );
<ide>
<add> var material = null;
<ide> if ( geometry.attributes.hasOwnProperty( 'color' ) ) {
<ide>
<del> material.vertexColors = true;
<add> material = new PointsMaterial( { vertexColors: true, sizeAttenuation: false, size: 2 } );
<add>
<add> } else {
<add>
<add> var _color = attributes.drawColor;
<add> var color = new Color( _color.r / 255.0, _color.g / 255.0, _color.b / 255.0 );
<add> material = new PointsMaterial( { color: color, sizeAttenuation: false, size: 2 } );
<ide>
<ide> }
<ide> | 1 |
Text | Text | move massive paragraph out of intro | 0c294e0010810e3d9a4bcfa72ab96ff2af0240a6 | <ide><path>guides/source/migrations.md
<ide> Migrations
<ide> ==========
<ide>
<add>Migrations are a feature of Active Record that allows you to evolve your
<add>database schema over time. Rather than write schema modifications in pure SQL,
<add>migrations allow you to use an easy Ruby DSL to describe changes to your
<add>tables.
<add>
<add>In this guide, you'll learn all about migrations including:
<add>
<add>* The generators you can use to create them
<add>* The methods Active Record provides to manipulate your database
<add>* The Rake tasks that manipulate them
<add>* How they relate to `schema.rb`
<add>
<add>--------------------------------------------------------------------------------
<add>
<add>What are Migrations?
<add>--------------------
<add>
<ide> Migrations are a convenient way for you to alter your database in a structured
<ide> and organized manner. You could edit fragments of SQL by hand but you would then
<ide> be responsible for telling other developers that they need to go and run them.
<ide> production machines next time you deploy.
<ide>
<ide> Active Record tracks which migrations have already been run so all you have to
<ide> do is update your source and run `rake db:migrate`. Active Record will work out
<del>which migrations should be run. Active Record will also update your `db/schema.rb` file to match the up-to-date structure of your database.
<add>which migrations should be run. Active Record will also update your
<add>`db/schema.rb` file to match the up-to-date structure of your database.
<ide>
<ide> Migrations also allow you to describe these transformations using Ruby. The
<ide> great thing about this is that (like most of Active Record's functionality) it
<ide> is database independent: you don't need to worry about the precise syntax of
<ide> drop down to raw SQL for database specific features). For example, you could use
<ide> SQLite3 in development, but MySQL in production.
<ide>
<del>In this guide, you'll learn all about migrations including:
<del>
<del>* The generators you can use to create them
<del>* The methods Active Record provides to manipulate your database
<del>* The Rake tasks that manipulate them
<del>* How they relate to `schema.rb`
<del>
<del>--------------------------------------------------------------------------------
<del>
<ide> Anatomy of a Migration
<ide> ----------------------
<ide> | 1 |
Ruby | Ruby | avoid extra allocations when don't need escaping | a2720dd0537cabe956406b591f0fd0a2c3964605 | <ide><path>actionview/lib/action_view/helpers/tag_helper.rb
<ide> def tag_option(key, value, escape)
<ide> if value.is_a?(Array)
<ide> value = escape ? safe_join(value, " ") : value.join(" ")
<ide> else
<del> value = escape ? ERB::Util.unwrapped_html_escape(value).dup : value.to_s.dup
<add> value = escape ? ERB::Util.unwrapped_html_escape(value) : value.to_s
<ide> end
<del> value.gsub!('"', """)
<add> value = value.gsub('"', """) if value.include?('"')
<ide> %(#{key}="#{value}")
<ide> end
<ide> | 1 |
Go | Go | isolate git from local system | 72119f5d9bcce3f4901b7ef2bf4b8181fc1b8062 | <ide><path>builder/remotecontext/git/gitutils.go
<ide> func checkoutGit(root, ref, subdir string) (string, error) {
<ide> }
<ide>
<ide> func gitWithinDir(dir string, args ...string) ([]byte, error) {
<add> args = append([]string{"-c", "protocol.file.allow=never"}, args...) // Block sneaky repositories from using repos from the filesystem as submodules.
<ide> cmd := exec.Command("git", args...)
<ide> cmd.Dir = dir
<add> cmd.Env = append(cmd.Env,
<add> "GIT_PROTOCOL_FROM_USER=0", // Disable unsafe remote protocols.
<add> "GIT_CONFIG_NOSYSTEM=1", // Disable reading from system gitconfig.
<add> "HOME=/dev/null", // Disable reading from user gitconfig.
<add> )
<ide> return cmd.CombinedOutput()
<ide> }
<ide>
<ide><path>builder/remotecontext/git/gitutils_test.go
<ide> package git // import "github.com/docker/docker/builder/remotecontext/git"
<ide>
<ide> import (
<add> "bytes"
<ide> "fmt"
<ide> "net/http"
<add> "net/http/cgi"
<ide> "net/http/httptest"
<ide> "net/url"
<ide> "os"
<add> "os/exec"
<ide> "path/filepath"
<ide> "runtime"
<ide> "strings"
<ide> func gitGetConfig(name string) string {
<ide> func TestCheckoutGit(t *testing.T) {
<ide> root := t.TempDir()
<ide>
<add> gitpath, err := exec.LookPath("git")
<add> assert.NilError(t, err)
<add> gitversion, _ := exec.Command(gitpath, "version").CombinedOutput()
<add> t.Logf("%s", gitversion) // E.g. "git version 2.30.2"
<add>
<add> // Serve all repositories under root using the Smart HTTP protocol so
<add> // they can be cloned. The Dumb HTTP protocol is incompatible with
<add> // shallow cloning but we unconditionally shallow-clone submodules, and
<add> // we explicitly disable the file protocol.
<add> // (Another option would be to use `git daemon` and the Git protocol,
<add> // but that listens on a fixed port number which is a recipe for
<add> // disaster in CI. Funnily enough, `git daemon --port=0` works but there
<add> // is no easy way to discover which port got picked!)
<add>
<add> // Associate git-http-backend logs with the current (sub)test.
<add> // Incompatible with parallel subtests.
<add> currentSubtest := t
<add> githttp := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
<add> var logs bytes.Buffer
<add> (&cgi.Handler{
<add> Path: gitpath,
<add> Args: []string{"http-backend"},
<add> Dir: root,
<add> Env: []string{
<add> "GIT_PROJECT_ROOT=" + root,
<add> "GIT_HTTP_EXPORT_ALL=1",
<add> },
<add> Stderr: &logs,
<add> }).ServeHTTP(w, r)
<add> if logs.Len() == 0 {
<add> return
<add> }
<add> for {
<add> line, err := logs.ReadString('\n')
<add> currentSubtest.Log("git-http-backend: " + line)
<add> if err != nil {
<add> break
<add> }
<add> }
<add> })
<add> server := httptest.NewServer(&githttp)
<add> defer server.Close()
<add>
<ide> autocrlf := gitGetConfig("core.autocrlf")
<ide> if !(autocrlf == "true" || autocrlf == "false" ||
<ide> autocrlf == "input" || autocrlf == "") {
<ide> func TestCheckoutGit(t *testing.T) {
<ide> must(gitWithinDir(subrepoDir, "add", "-A"))
<ide> must(gitWithinDir(subrepoDir, "commit", "-am", "Subrepo initial"))
<ide>
<del> must(gitWithinDir(gitDir, "submodule", "add", subrepoDir, "sub"))
<add> must(gitWithinDir(gitDir, "submodule", "add", server.URL+"/subrepo", "sub"))
<ide> must(gitWithinDir(gitDir, "add", "-A"))
<ide> must(gitWithinDir(gitDir, "commit", "-am", "With submodule"))
<ide>
<ide> func TestCheckoutGit(t *testing.T) {
<ide>
<ide> for _, c := range cases {
<ide> t.Run(c.frag, func(t *testing.T) {
<add> currentSubtest = t
<ide> ref, subdir := getRefAndSubdir(c.frag)
<del> r, err := cloneGitRepo(gitRepo{remote: gitDir, ref: ref, subdir: subdir})
<add> r, err := cloneGitRepo(gitRepo{remote: server.URL + "/repo", ref: ref, subdir: subdir})
<ide>
<ide> if c.fail {
<ide> assert.Check(t, is.ErrorContains(err, "")) | 2 |
Python | Python | expose more attributes in the slicehost driver | a05ae1cda86cb5538b2a16267671a25dd91bdec7 | <ide><path>libcloud/drivers/slicehost.py
<ide> def _to_node(self, element):
<ide> except:
<ide> state = NodeState.UNKNOWN
<ide>
<add> # for consistency with other drivers, we put this in two places.
<add> node_attrs['password'] = node_attrs['root-password']
<ide> n = Node(id=element.findtext('id'),
<ide> name=element.findtext('name'),
<ide> state=state,
<ide> public_ip=[public_ip],
<ide> private_ip=[private_ip],
<ide> driver=self.connection.driver,
<del> extra={
<del> 'password': element.findtext('root-password'),
<del> })
<add> extra=node_attrs)
<ide> return n
<ide>
<ide> def _to_sizes(self, object): | 1 |
Javascript | Javascript | remove unnecessary var declaration | 0c77b2f3eb28471ad664b6272b7426603b757527 | <ide><path>src/renderers/dom/client/ReactEventListener.js
<ide> var ReactEventListener = {
<ide> *
<ide> * @param {string} topLevelType Record from `EventConstants`.
<ide> * @param {string} handlerBaseName Event name (e.g. "click").
<del> * @param {object} handle Element on which to attach listener.
<add> * @param {object} element Element on which to attach listener.
<ide> * @return {?object} An object with a remove function which will forcefully
<ide> * remove the listener.
<ide> * @internal
<ide> */
<del> trapBubbledEvent: function(topLevelType, handlerBaseName, handle) {
<del> var element = handle;
<add> trapBubbledEvent: function(topLevelType, handlerBaseName, element) {
<ide> if (!element) {
<ide> return null;
<ide> }
<ide> var ReactEventListener = {
<ide> *
<ide> * @param {string} topLevelType Record from `EventConstants`.
<ide> * @param {string} handlerBaseName Event name (e.g. "click").
<del> * @param {object} handle Element on which to attach listener.
<add> * @param {object} element Element on which to attach listener.
<ide> * @return {?object} An object with a remove function which will forcefully
<ide> * remove the listener.
<ide> * @internal
<ide> */
<del> trapCapturedEvent: function(topLevelType, handlerBaseName, handle) {
<del> var element = handle;
<add> trapCapturedEvent: function(topLevelType, handlerBaseName, element) {
<ide> if (!element) {
<ide> return null;
<ide> } | 1 |
Javascript | Javascript | update vendored modules | 182379305a92c86f415837f30cb0afac3acf361d | <ide><path>src/vendor/core/mapObject.js
<ide> * @providesModule mapObject
<ide> */
<ide>
<del>"use strict";
<add>'use strict';
<add>
<add>var hasOwnProperty = Object.prototype.hasOwnProperty;
<ide>
<ide> /**
<del> * For each key/value pair, invokes callback func and constructs a resulting
<del> * object which contains, for every key in obj, values that are the result of
<del> * of invoking the function:
<del> *
<del> * func(value, key, iteration)
<del> *
<del> * Grepable names:
<del> *
<del> * function objectMap()
<del> * function objMap()
<del> *
<del> * @param {?object} obj Object to map keys over
<del> * @param {function} func Invoked for each key/val pair.
<del> * @param {?*} context
<del> * @return {?object} Result of mapping or null if obj is falsey
<add> * Executes the provided `callback` once for each enumerable own property in the
<add> * object and constructs a new object from the results. The `callback` is
<add> * invoked with three arguments:
<add> *
<add> * - the property value
<add> * - the property name
<add> * - the object being traversed
<add> *
<add> * Properties that are added after the call to `mapObject` will not be visited
<add> * by `callback`. If the values of existing properties are changed, the value
<add> * passed to `callback` will be the value at the time `mapObject` visits them.
<add> * Properties that are deleted before being visited are not visited.
<add> *
<add> * @grep function objectMap()
<add> * @grep function objMap()
<add> *
<add> * @param {?object} object
<add> * @param {function} callback
<add> * @param {*} context
<add> * @return {?object}
<ide> */
<del>function mapObject(obj, func, context) {
<del> if (!obj) {
<add>function mapObject(object, callback, context) {
<add> if (!object) {
<ide> return null;
<ide> }
<del> var i = 0;
<del> var ret = {};
<del> for (var key in obj) {
<del> if (obj.hasOwnProperty(key)) {
<del> ret[key] = func.call(context, obj[key], key, i++);
<add> var result = {};
<add> for (var name in object) {
<add> if (hasOwnProperty.call(object, name)) {
<add> result[name] = callback.call(context, object[name], name, object);
<ide> }
<ide> }
<del> return ret;
<add> return result;
<ide> }
<ide>
<ide> module.exports = mapObject;
<ide><path>src/vendor/core/merge.js
<ide> * @return {object} The shallow extension of one by two.
<ide> */
<ide> var merge = function(one, two) {
<del> var result = {};
<del> if (one != null) {
<del> Object.assign(result, one);
<del> }
<del> if (two != null) {
<del> Object.assign(result, two);
<del> }
<del> return result;
<add> return Object.assign({}, one, two);
<ide> };
<ide>
<ide> module.exports = merge;
<ide><path>src/vendor/core/mergeInto.js
<ide>
<ide> "use strict";
<ide>
<del>/**
<del> * Shallow merges two structures by mutating the first parameter.
<del> *
<del> * @param {object|function} one Object to be merged into.
<del> * @param {?object} two Optional object with properties to merge from.
<del> * @return {object|function} The first argument coerced into an object.
<del> */
<del>function mergeInto(one, two) {
<del> if (two != null) {
<del> return Object.assign(one, two);
<del> } else {
<del> // This ensures that we throw the right error if one is of the wrong type
<del> return Object.assign(one);
<del> }
<del>}
<del>
<del>module.exports = mergeInto;
<add>module.exports = Object.assign; | 3 |
Ruby | Ruby | define activesupport#to_param as to_str - closes | 1fa059cd017c134499835593ba29620c4cd7358c | <ide><path>actionpack/test/template/url_helper_test.rb
<ide> class UrlHelperTest < ActiveSupport::TestCase
<ide> routes.draw do
<ide> match "/" => "foo#bar"
<ide> match "/other" => "foo#other"
<add> match "/article/:id" => "foo#article", :as => :article
<ide> end
<ide>
<ide> include routes.url_helpers
<ide> def test_link_tag_using_block_in_erb
<ide> assert_equal '<a href="/">Example site</a>', out
<ide> end
<ide>
<add> def test_link_tag_with_html_safe_string
<add> assert_dom_equal(
<add> "<a href=\"/article/Gerd_M%C3%BCller\">Gerd Müller</a>",
<add> link_to("Gerd Müller", article_path("Gerd_Müller".html_safe))
<add> )
<add> end
<add>
<ide> def test_link_to_unless
<ide> assert_equal "Showing", link_to_unless(true, "Showing", url_hash)
<ide>
<ide><path>activesupport/lib/active_support/core_ext/string/output_safety.rb
<ide> def to_s
<ide> self
<ide> end
<ide>
<add> def to_param
<add> to_str
<add> end
<add>
<ide> def encode_with(coder)
<ide> coder.represent_scalar nil, to_str
<ide> end
<ide><path>activesupport/test/core_ext/string_ext_test.rb
<ide> def test_string_squish
<ide> # And changes the original string:
<ide> assert_equal original, expected
<ide> end
<del>
<add>
<ide> def test_string_inquiry
<ide> assert "production".inquiry.production?
<ide> assert !"production".inquiry.development?
<ide> def to_s
<ide> assert !'ruby'.encoding_aware?
<ide> end
<ide> end
<add>
<add> test "call to_param returns a normal string" do
<add> string = @string.html_safe
<add> assert string.html_safe?
<add> assert !string.to_param.html_safe?
<add> end
<ide> end
<ide>
<ide> class StringExcludeTest < ActiveSupport::TestCase | 3 |
Javascript | Javascript | add error checking to include parser | 807a8ec729c715f6e4008c48c0cd49b0d4e66dbd | <ide><path>src/renderers/webgl/WebGLProgram.js
<ide> THREE.WebGLProgram = ( function () {
<ide> var pattern = /#include[ \t]+<([\w\d.]+)>/g;
<ide>
<ide> function replace( match, include ) {
<del> return parseIncludes( THREE.ShaderChunk[ include ] );
<add> var replace = THREE.ShaderChunk[ include ];
<add> if( ! replace ) throw new Error( "can not resolve #include <"+include+">");
<add> return parseIncludes( replace );
<ide>
<ide> }
<ide> | 1 |
Ruby | Ruby | fix conditional for 10.4 | 64b472788acf8fe5087fabea3efa23036b3efcc2 | <ide><path>Library/Homebrew/os/mac.rb
<ide> def macports_or_fink
<ide> end
<ide>
<ide> def prefer_64_bit?
<del> Hardware::CPU.is_64_bit? and version != :leopard
<add> Hardware::CPU.is_64_bit? and version > :leopard
<ide> end
<ide>
<ide> def preferred_arch | 1 |
Javascript | Javascript | add workspace center | 7f5ad9a359aebfc6bc76df718f71bd20b34ed9e6 | <ide><path>src/workspace-center.js
<add>'use strict'
<add>
<add>const TextEditor = require('./text-editor')
<add>
<add>module.exports = class WorkspaceCenter {
<add> constructor (paneContainer) {
<add> this.paneContainer = paneContainer
<add> }
<add>
<add> /*
<add> Section: Event Subscription
<add> */
<add>
<add> // Essential: Invoke the given callback with all current and future text
<add> // editors in the workspace.
<add> //
<add> // * `callback` {Function} to be called with current and future text editors.
<add> // * `editor` An {TextEditor} that is present in {::getTextEditors} at the time
<add> // of subscription or that is added at some later time.
<add> //
<add> // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
<add> observeTextEditors (callback) {
<add> for (let textEditor of this.getTextEditors()) { callback(textEditor) }
<add> return this.onDidAddTextEditor(({textEditor}) => callback(textEditor))
<add> }
<add>
<add> // Essential: Invoke the given callback with all current and future panes items
<add> // in the workspace.
<add> //
<add> // * `callback` {Function} to be called with current and future pane items.
<add> // * `item` An item that is present in {::getPaneItems} at the time of
<add> // subscription or that is added at some later time.
<add> //
<add> // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
<add> observePaneItems (callback) { return this.paneContainer.observePaneItems(callback) }
<add>
<add> // Essential: Invoke the given callback when the active pane item changes.
<add> //
<add> // Because observers are invoked synchronously, it's important not to perform
<add> // any expensive operations via this method. Consider
<add> // {::onDidStopChangingActivePaneItem} to delay operations until after changes
<add> // stop occurring.
<add> //
<add> // * `callback` {Function} to be called when the active pane item changes.
<add> // * `item` The active pane item.
<add> //
<add> // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
<add> onDidChangeActivePaneItem (callback) {
<add> return this.paneContainer.onDidChangeActivePaneItem(callback)
<add> }
<add>
<add> // Essential: Invoke the given callback when the active pane item stops
<add> // changing.
<add> //
<add> // Observers are called asynchronously 100ms after the last active pane item
<add> // change. Handling changes here rather than in the synchronous
<add> // {::onDidChangeActivePaneItem} prevents unneeded work if the user is quickly
<add> // changing or closing tabs and ensures critical UI feedback, like changing the
<add> // highlighted tab, gets priority over work that can be done asynchronously.
<add> //
<add> // * `callback` {Function} to be called when the active pane item stopts
<add> // changing.
<add> // * `item` The active pane item.
<add> //
<add> // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
<add> onDidStopChangingActivePaneItem (callback) {
<add> return this.paneContainer.onDidStopChangingActivePaneItem(callback)
<add> }
<add>
<add> // Essential: Invoke the given callback with the current active pane item and
<add> // with all future active pane items in the workspace.
<add> //
<add> // * `callback` {Function} to be called when the active pane item changes.
<add> // * `item` The current active pane item.
<add> //
<add> // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
<add> observeActivePaneItem (callback) {
<add> return this.paneContainer.observeActivePaneItem(callback)
<add> }
<add>
<add> // Extended: Invoke the given callback when a pane is added to the workspace.
<add> //
<add> // * `callback` {Function} to be called panes are added.
<add> // * `event` {Object} with the following keys:
<add> // * `pane` The added pane.
<add> //
<add> // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
<add> onDidAddPane (callback) {
<add> return this.paneContainer.onDidAddPane(callback)
<add> }
<add>
<add> // Extended: Invoke the given callback before a pane is destroyed in the
<add> // workspace.
<add> //
<add> // * `callback` {Function} to be called before panes are destroyed.
<add> // * `event` {Object} with the following keys:
<add> // * `pane` The pane to be destroyed.
<add> //
<add> // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
<add> onWillDestroyPane (callback) {
<add> return this.paneContainer.onWillDestroyPane(callback)
<add> }
<add>
<add> // Extended: Invoke the given callback when a pane is destroyed in the
<add> // workspace.
<add> //
<add> // * `callback` {Function} to be called panes are destroyed.
<add> // * `event` {Object} with the following keys:
<add> // * `pane` The destroyed pane.
<add> //
<add> // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
<add> onDidDestroyPane (callback) {
<add> return this.paneContainer.onDidDestroyPane(callback)
<add> }
<add>
<add> // Extended: Invoke the given callback with all current and future panes in the
<add> // workspace.
<add> //
<add> // * `callback` {Function} to be called with current and future panes.
<add> // * `pane` A {Pane} that is present in {::getPanes} at the time of
<add> // subscription or that is added at some later time.
<add> //
<add> // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
<add> observePanes (callback) {
<add> return this.paneContainer.observePanes(callback)
<add> }
<add>
<add> // Extended: Invoke the given callback when the active pane changes.
<add> //
<add> // * `callback` {Function} to be called when the active pane changes.
<add> // * `pane` A {Pane} that is the current return value of {::getActivePane}.
<add> //
<add> // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
<add> onDidChangeActivePane (callback) {
<add> return this.paneContainer.onDidChangeActivePane(callback)
<add> }
<add>
<add> // Extended: Invoke the given callback with the current active pane and when
<add> // the active pane changes.
<add> //
<add> // * `callback` {Function} to be called with the current and future active#
<add> // panes.
<add> // * `pane` A {Pane} that is the current return value of {::getActivePane}.
<add> //
<add> // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
<add> observeActivePane (callback) {
<add> return this.paneContainer.observeActivePane(callback)
<add> }
<add>
<add> // Extended: Invoke the given callback when a pane item is added to the
<add> // workspace.
<add> //
<add> // * `callback` {Function} to be called when pane items are added.
<add> // * `event` {Object} with the following keys:
<add> // * `item` The added pane item.
<add> // * `pane` {Pane} containing the added item.
<add> // * `index` {Number} indicating the index of the added item in its pane.
<add> //
<add> // Returns a {Disposable} on which `.dispose()` can be called to unsubscribe.
<add> onDidAddPaneItem (callback) {
<add> return this.paneContainer.onDidAddPaneItem(callback)
<add> }
<add>
<add> // Extended: Invoke the given callback when a pane item is about to be
<add> // destroyed, before the user is prompted to save it.
<add> //
<add> // * `callback` {Function} to be called before pane items are destroyed.
<add> // * `event` {Object} with the following keys:
<add> // * `item` The item to be destroyed.
<add> // * `pane` {Pane} containing the item to be destroyed.
<add> // * `index` {Number} indicating the index of the item to be destroyed in
<add> // its pane.
<add> //
<add> // Returns a {Disposable} on which `.dispose` can be called to unsubscribe.
<add> onWillDestroyPaneItem (callback) {
<add> return this.paneContainer.onWillDestroyPaneItem(callback)
<add> }
<add>
<add> // Extended: Invoke the given callback when a pane item is destroyed.
<add> //
<add> // * `callback` {Function} to be called when pane items are destroyed.
<add> // * `event` {Object} with the following keys:
<add> // * `item` The destroyed item.
<add> // * `pane` {Pane} containing the destroyed item.
<add> // * `index` {Number} indicating the index of the destroyed item in its
<add> // pane.
<add> //
<add> // Returns a {Disposable} on which `.dispose` can be called to unsubscribe.
<add> onDidDestroyPaneItem (callback) {
<add> return this.paneContainer.onDidDestroyPaneItem(callback)
<add> }
<add>
<add> /*
<add> Section: Pane Items
<add> */
<add>
<add> // Essential: Get all pane items in the workspace.
<add> //
<add> // Returns an {Array} of items.
<add> getPaneItems () {
<add> return this.paneContainer.getPaneItems()
<add> }
<add>
<add> // Essential: Get the active {Pane}'s active item.
<add> //
<add> // Returns an pane item {Object}.
<add> getActivePaneItem () {
<add> return this.paneContainer.getActivePaneItem()
<add> }
<add>
<add> // Essential: Get all text editors in the workspace.
<add> //
<add> // Returns an {Array} of {TextEditor}s.
<add> getTextEditors () {
<add> return this.getPaneItems().filter(item => item instanceof TextEditor)
<add> }
<add>
<add> // Essential: Get the active item if it is an {TextEditor}.
<add> //
<add> // Returns an {TextEditor} or `undefined` if the current active item is not an
<add> // {TextEditor}.
<add> getActiveTextEditor () {
<add> const activeItem = this.getActivePaneItem()
<add> if (activeItem instanceof TextEditor) { return activeItem }
<add> }
<add>
<add> // Save all pane items.
<add> saveAll () {
<add> this.paneContainer.saveAll()
<add> }
<add>
<add> confirmClose (options) {
<add> return this.paneContainer.confirmClose(options)
<add> }
<add>
<add> /*
<add> Section: Panes
<add> */
<add>
<add> // Extended: Get all panes in the workspace.
<add> //
<add> // Returns an {Array} of {Pane}s.
<add> getPanes () {
<add> return this.paneContainer.getPanes()
<add> }
<add>
<add> // Extended: Get the active {Pane}.
<add> //
<add> // Returns a {Pane}.
<add> getActivePane () {
<add> return this.paneContainer.getActivePane()
<add> }
<add>
<add> // Extended: Make the next pane active.
<add> activateNextPane () {
<add> return this.paneContainer.activateNextPane()
<add> }
<add>
<add> // Extended: Make the previous pane active.
<add> activatePreviousPane () {
<add> return this.paneContainer.activatePreviousPane()
<add> }
<add>
<add> paneForURI (uri) {
<add> return this.paneContainer.paneForURI(uri)
<add> }
<add>
<add> paneForItem (item) {
<add> return this.paneContainer.paneForItem(item)
<add> }
<add>
<add> // Destroy (close) the active pane.
<add> destroyActivePane () {
<add> const activePane = this.getActivePane()
<add> if (activePane != null) {
<add> activePane.destroy()
<add> }
<add> }
<add>}
<ide><path>src/workspace.js
<ide> const PaneContainer = require('./pane-container')
<ide> const Panel = require('./panel')
<ide> const PanelContainer = require('./panel-container')
<ide> const Task = require('./task')
<add>const WorkspaceCenter = require('./workspace-center')
<ide>
<ide> // Essential: Represents the state of the user interface for the entire window.
<ide> // An instance of this class is available via the `atom.workspace` global.
<ide> module.exports = class Workspace extends Model {
<ide> this.defaultDirectorySearcher = new DefaultDirectorySearcher()
<ide> this.consumeServices(this.packageManager)
<ide>
<add> this.center = new WorkspaceCenter(this.paneContainer)
<add>
<ide> this.panelContainers = {
<ide> top: new PanelContainer({location: 'top'}),
<ide> left: new PanelContainer({location: 'left'}),
<ide> module.exports = class Workspace extends Model {
<ide> }
<ide> }
<ide>
<add> /*
<add> Section: Pane Locations
<add> */
<add>
<add> getCenter () {
<add> return this.center
<add> }
<add>
<ide> /*
<ide> Section: Panels
<ide> | 2 |
Java | Java | expand hints conditions support in runtimehints | 8af1496b376165c3bfadacfa8e0da8746aa5774c | <ide><path>spring-context/src/test/java/org/springframework/context/annotation/ConfigurationClassPostProcessorAotContributionTests.java
<ide> import org.springframework.aot.generate.InMemoryGeneratedFiles;
<ide> import org.springframework.aot.generate.MethodGenerator;
<ide> import org.springframework.aot.generate.MethodReference;
<add>import org.springframework.aot.hint.ResourcePatternHint;
<ide> import org.springframework.aot.test.generator.compile.Compiled;
<ide> import org.springframework.aot.test.generator.compile.TestCompiler;
<ide> import org.springframework.beans.factory.aot.BeanFactoryInitializationAotContribution;
<ide> void applyToWhenHasImportAwareConfigurationRegistersHints() {
<ide> assertThat(generationContext.getRuntimeHints().resources().resourcePatterns())
<ide> .singleElement()
<ide> .satisfies(resourceHint -> assertThat(resourceHint.getIncludes())
<add> .map(ResourcePatternHint::getPattern)
<ide> .containsOnly(
<ide> "org/springframework/context/testfixture/context/generator/annotation/ImportConfiguration.class"));
<ide> }
<ide><path>spring-core/src/main/java/org/springframework/aot/generate/GenerationContext.java
<ide>
<ide> package org.springframework.aot.generate;
<ide>
<del>import org.springframework.aot.hint.JavaSerializationHints;
<ide> import org.springframework.aot.hint.ProxyHints;
<ide> import org.springframework.aot.hint.ReflectionHints;
<ide> import org.springframework.aot.hint.ResourceHints;
<ide> import org.springframework.aot.hint.RuntimeHints;
<add>import org.springframework.aot.hint.SerializationHints;
<ide>
<ide> /**
<ide> * Central interface used for code generation.
<ide> public interface GenerationContext {
<ide> /**
<ide> * Return the {@link RuntimeHints} being used by the context. Used to record
<ide> * {@link ReflectionHints reflection}, {@link ResourceHints resource},
<del> * {@link JavaSerializationHints serialization} and {@link ProxyHints proxy}
<add> * {@link SerializationHints serialization} and {@link ProxyHints proxy}
<ide> * hints so that the application can run as a native image.
<ide> * @return the runtime hints
<ide> */
<ide><path>spring-core/src/main/java/org/springframework/aot/hint/ClassProxyHint.java
<ide> import java.util.List;
<ide> import java.util.Objects;
<ide>
<add>import org.springframework.lang.Nullable;
<add>
<ide> /**
<ide> * A hint that describes the need for a proxy against a concrete class.
<ide> *
<ide> * @author Stephane Nicoll
<add> * @author Brian Clozel
<ide> * @since 6.0
<ide> */
<del>public final class ClassProxyHint {
<add>public final class ClassProxyHint implements ConditionalHint {
<ide>
<ide> private final TypeReference targetClass;
<ide>
<ide> private final List<TypeReference> proxiedInterfaces;
<ide>
<add> @Nullable
<add> private final TypeReference reachableType;
<add>
<ide>
<ide> private ClassProxyHint(Builder builder) {
<ide> this.targetClass = builder.targetClass;
<ide> this.proxiedInterfaces = builder.proxiedInterfaces.stream().distinct().toList();
<add> this.reachableType = builder.reachableType;
<ide> }
<ide>
<ide> /**
<ide> public List<TypeReference> getProxiedInterfaces() {
<ide> return this.proxiedInterfaces;
<ide> }
<ide>
<add> @Nullable
<add> @Override
<add> public TypeReference getReachableType() {
<add> return this.reachableType;
<add> }
<add>
<ide> @Override
<ide> public boolean equals(Object o) {
<ide> if (this == o) {
<ide> public boolean equals(Object o) {
<ide> }
<ide> ClassProxyHint that = (ClassProxyHint) o;
<ide> return this.targetClass.equals(that.targetClass)
<del> && this.proxiedInterfaces.equals(that.proxiedInterfaces);
<add> && this.proxiedInterfaces.equals(that.proxiedInterfaces)
<add> && Objects.equals(this.reachableType, that.reachableType);
<ide> }
<ide>
<ide> @Override
<ide> public static class Builder {
<ide>
<ide> private final LinkedList<TypeReference> proxiedInterfaces = new LinkedList<>();
<ide>
<add> @Nullable
<add> private TypeReference reachableType;
<add>
<ide>
<ide> Builder(TypeReference targetClass) {
<ide> this.targetClass = targetClass;
<ide> public Builder proxiedInterfaces(Class<?>... proxiedInterfaces) {
<ide> return this;
<ide> }
<ide>
<add> /**
<add> * Make this hint conditional on the fact that the specified type
<add> * can be resolved.
<add> * @param reachableType the type that should be reachable for this
<add> * hint to apply
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public Builder onReachableType(TypeReference reachableType) {
<add> this.reachableType = reachableType;
<add> return this;
<add> }
<add>
<ide> /**
<ide> * Create a {@link ClassProxyHint} based on the state of this builder.
<ide> * @return a class proxy hint
<ide><path>spring-core/src/main/java/org/springframework/aot/hint/ConditionalHint.java
<add>/*
<add> * Copyright 2002-2022 the original author or authors.
<add> *
<add> * Licensed under the Apache License, Version 2.0 (the "License");
<add> * you may not use this file except in compliance with the License.
<add> * You may obtain a copy of the License at
<add> *
<add> * https://www.apache.org/licenses/LICENSE-2.0
<add> *
<add> * Unless required by applicable law or agreed to in writing, software
<add> * distributed under the License is distributed on an "AS IS" BASIS,
<add> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
<add> * See the License for the specific language governing permissions and
<add> * limitations under the License.
<add> */
<add>
<add>package org.springframework.aot.hint;
<add>
<add>import org.springframework.lang.Nullable;
<add>import org.springframework.util.ClassUtils;
<add>
<add>/**
<add> * Contract for {@link RuntimeHints runtime hints} that only apply
<add> * if the described condition is met.
<add> *
<add> * @author Brian Clozel
<add> * @since 6.0
<add> */
<add>public interface ConditionalHint {
<add>
<add> /**
<add> * Return the type that should be reachable for this hint to apply, or
<add> * {@code null} if this hint should always been applied.
<add> * @return the reachable type, if any
<add> */
<add> @Nullable
<add> TypeReference getReachableType();
<add>
<add> /**
<add> * Whether the condition described for this hint is met. If it is not,
<add> * the hint does not apply.
<add> * <p>Instead of checking for actual reachability of a type in the
<add> * application, the classpath is checked for the presence of this
<add> * type as a simple heuristic.
<add> * @param classLoader the current classloader
<add> * @return whether the condition is met and the hint applies
<add> */
<add> default boolean conditionMatches(ClassLoader classLoader) {
<add> TypeReference reachableType = getReachableType();
<add> if (reachableType != null) {
<add> return ClassUtils.isPresent(reachableType.getCanonicalName(), classLoader);
<add> }
<add> return true;
<add> }
<add>
<add>}
<ide><path>spring-core/src/main/java/org/springframework/aot/hint/JavaSerializationHint.java
<add>/*
<add> * Copyright 2002-2022 the original author or authors.
<add> *
<add> * Licensed under the Apache License, Version 2.0 (the "License");
<add> * you may not use this file except in compliance with the License.
<add> * You may obtain a copy of the License at
<add> *
<add> * https://www.apache.org/licenses/LICENSE-2.0
<add> *
<add> * Unless required by applicable law or agreed to in writing, software
<add> * distributed under the License is distributed on an "AS IS" BASIS,
<add> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
<add> * See the License for the specific language governing permissions and
<add> * limitations under the License.
<add> */
<add>
<add>package org.springframework.aot.hint;
<add>
<add>
<add>import java.io.Serializable;
<add>import java.util.Objects;
<add>
<add>import org.springframework.lang.Nullable;
<add>
<add>/**
<add> * A hint that describes the need for Java serialization at runtime.
<add> *
<add> * @author Brian Clozel
<add> * @since 6.0
<add> */
<add>public class JavaSerializationHint implements ConditionalHint {
<add>
<add> private final TypeReference type;
<add>
<add> @Nullable
<add> private final TypeReference reachableType;
<add>
<add> JavaSerializationHint(Builder builder) {
<add> this.type = builder.type;
<add> this.reachableType = builder.reachableType;
<add> }
<add>
<add> /**
<add> * Return the {@link TypeReference type} that needs to be serialized using
<add> * Java serialization at runtime.
<add> * @return a {@link Serializable} type
<add> */
<add> public TypeReference getType() {
<add> return this.type;
<add> }
<add>
<add> @Override
<add> @Nullable
<add> public TypeReference getReachableType() {
<add> return this.reachableType;
<add> }
<add>
<add> @Override
<add> public boolean equals(Object o) {
<add> if (this == o) {
<add> return true;
<add> }
<add> if (o == null || getClass() != o.getClass()) {
<add> return false;
<add> }
<add> JavaSerializationHint that = (JavaSerializationHint) o;
<add> return this.type.equals(that.type)
<add> && Objects.equals(this.reachableType, that.reachableType);
<add> }
<add>
<add> @Override
<add> public int hashCode() {
<add> return Objects.hash(this.type, this.reachableType);
<add> }
<add>
<add>
<add> /**
<add> * Builder for {@link JavaSerializationHint}.
<add> */
<add> public static class Builder {
<add>
<add> private final TypeReference type;
<add>
<add> @Nullable
<add> private TypeReference reachableType;
<add>
<add>
<add> Builder(TypeReference type) {
<add> this.type = type;
<add> }
<add>
<add> /**
<add> * Make this hint conditional on the fact that the specified type
<add> * can be resolved.
<add> * @param reachableType the type that should be reachable for this
<add> * hint to apply
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public Builder onReachableType(TypeReference reachableType) {
<add> this.reachableType = reachableType;
<add> return this;
<add> }
<add>
<add> /**
<add> * Create a {@link JavaSerializationHint} based on the state of this builder.
<add> * @return a java serialization hint
<add> */
<add> JavaSerializationHint build() {
<add> return new JavaSerializationHint(this);
<add> }
<add>
<add> }
<add>}
<ide><path>spring-core/src/main/java/org/springframework/aot/hint/JavaSerializationHints.java
<del>/*
<del> * Copyright 2002-2022 the original author or authors.
<del> *
<del> * Licensed under the Apache License, Version 2.0 (the "License");
<del> * you may not use this file except in compliance with the License.
<del> * You may obtain a copy of the License at
<del> *
<del> * https://www.apache.org/licenses/LICENSE-2.0
<del> *
<del> * Unless required by applicable law or agreed to in writing, software
<del> * distributed under the License is distributed on an "AS IS" BASIS,
<del> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
<del> * See the License for the specific language governing permissions and
<del> * limitations under the License.
<del> */
<del>
<del>package org.springframework.aot.hint;
<del>
<del>import java.io.Serializable;
<del>import java.util.LinkedHashSet;
<del>import java.util.Set;
<del>import java.util.stream.Stream;
<del>
<del>/**
<del> * Gather the need for Java serialization at runtime.
<del> *
<del> * @author Stephane Nicoll
<del> * @since 6.0
<del> * @see Serializable
<del> */
<del>public class JavaSerializationHints {
<del>
<del> private final Set<TypeReference> types;
<del>
<del>
<del> public JavaSerializationHints() {
<del> this.types = new LinkedHashSet<>();
<del> }
<del>
<del> /**
<del> * Return the {@link TypeReference types} that need to be serialized using
<del> * Java serialization at runtime.
<del> * @return a stream of {@link Serializable} types
<del> */
<del> public Stream<TypeReference> types() {
<del> return this.types.stream();
<del> }
<del>
<del> /**
<del> * Register that the type defined by the specified {@link TypeReference}
<del> * need to be serialized using java serialization.
<del> * @param type the type to register
<del> * @return {@code this}, to facilitate method chaining
<del> */
<del> public JavaSerializationHints registerType(TypeReference type) {
<del> this.types.add(type);
<del> return this;
<del> }
<del>
<del> /**
<del> * Register that the specified type need to be serialized using java
<del> * serialization.
<del> * @param type the type to register
<del> * @return {@code this}, to facilitate method chaining
<del> */
<del> public JavaSerializationHints registerType(Class<? extends Serializable> type) {
<del> return registerType(TypeReference.of(type));
<del> }
<del>
<del>}
<ide><path>spring-core/src/main/java/org/springframework/aot/hint/JdkProxyHint.java
<ide> import java.util.List;
<ide> import java.util.Objects;
<ide>
<add>import org.springframework.lang.Nullable;
<add>
<ide> /**
<ide> * A hint that describes the need of a JDK {@link Proxy}, that is an
<ide> * interfaces-based proxy.
<ide> *
<ide> * @author Stephane Nicoll
<add> * @author Brian Clozel
<ide> * @since 6.0
<ide> */
<del>public final class JdkProxyHint {
<add>public final class JdkProxyHint implements ConditionalHint {
<ide>
<ide> private final List<TypeReference> proxiedInterfaces;
<ide>
<add> @Nullable
<add> private final TypeReference reachableType;
<add>
<ide>
<ide> private JdkProxyHint(Builder builder) {
<ide> this.proxiedInterfaces = List.copyOf(builder.proxiedInterfaces);
<add> this.reachableType = builder.reachableType;
<ide> }
<ide>
<ide> /**
<ide> public List<TypeReference> getProxiedInterfaces() {
<ide> return this.proxiedInterfaces;
<ide> }
<ide>
<add> @Nullable
<add> @Override
<add> public TypeReference getReachableType() {
<add> return this.reachableType;
<add> }
<add>
<ide> @Override
<ide> public boolean equals(Object o) {
<ide> if (this == o) {
<ide> public boolean equals(Object o) {
<ide> return false;
<ide> }
<ide> JdkProxyHint that = (JdkProxyHint) o;
<del> return this.proxiedInterfaces.equals(that.proxiedInterfaces);
<add> return this.proxiedInterfaces.equals(that.proxiedInterfaces)
<add> && Objects.equals(this.reachableType, that.reachableType);
<ide> }
<ide>
<ide> @Override
<ide> public static class Builder {
<ide>
<ide> private final LinkedList<TypeReference> proxiedInterfaces;
<ide>
<add> @Nullable
<add> private TypeReference reachableType;
<add>
<add>
<ide> Builder() {
<ide> this.proxiedInterfaces = new LinkedList<>();
<ide> }
<ide> public Builder proxiedInterfaces(Class<?>... proxiedInterfaces) {
<ide> return this;
<ide> }
<ide>
<add> /**
<add> * Make this hint conditional on the fact that the specified type
<add> * can be resolved.
<add> * @param reachableType the type that should be reachable for this
<add> * hint to apply
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public Builder onReachableType(TypeReference reachableType) {
<add> this.reachableType = reachableType;
<add> return this;
<add> }
<add>
<ide> /**
<ide> * Create a {@link JdkProxyHint} based on the state of this builder.
<ide> * @return a jdk proxy hint
<ide><path>spring-core/src/main/java/org/springframework/aot/hint/ResourceBundleHint.java
<ide>
<ide> package org.springframework.aot.hint;
<ide>
<add>import java.util.Objects;
<ide> import java.util.ResourceBundle;
<ide>
<add>import org.springframework.lang.Nullable;
<add>
<ide> /**
<del> * A hint that describes the need to access to a {@link ResourceBundle}.
<add> * A hint that describes the need to access a {@link ResourceBundle}.
<ide> *
<ide> * @author Stephane Nicoll
<add> * @author Brian Clozel
<ide> * @since 6.0
<ide> */
<del>public class ResourceBundleHint {
<add>public final class ResourceBundleHint implements ConditionalHint {
<ide>
<ide> private final String baseName;
<ide>
<add> @Nullable
<add> private TypeReference reachableType;
<add>
<ide>
<del> ResourceBundleHint(String baseName) {
<del> this.baseName = baseName;
<add> ResourceBundleHint(Builder builder) {
<add> this.baseName = builder.baseName;
<add> this.reachableType = builder.reachableType;
<ide> }
<ide>
<ide> /**
<ide> public String getBaseName() {
<ide> return this.baseName;
<ide> }
<ide>
<add> @Nullable
<add> @Override
<add> public TypeReference getReachableType() {
<add> return this.reachableType;
<add> }
<add>
<add> @Override
<add> public boolean equals(Object o) {
<add> if (this == o) {
<add> return true;
<add> }
<add> if (o == null || getClass() != o.getClass()) {
<add> return false;
<add> }
<add> ResourceBundleHint that = (ResourceBundleHint) o;
<add> return this.baseName.equals(that.baseName)
<add> && Objects.equals(this.reachableType, that.reachableType);
<add> }
<add>
<add> @Override
<add> public int hashCode() {
<add> return Objects.hash(this.baseName, this.reachableType);
<add> }
<add>
<add> /**
<add> * Builder for {@link ResourceBundleHint}.
<add> */
<add> public static class Builder {
<add>
<add> private String baseName;
<add>
<add> @Nullable
<add> private TypeReference reachableType;
<add>
<add> /**
<add> * Make this hint conditional on the fact that the specified type
<add> * can be resolved.
<add> * @param reachableType the type that should be reachable for this
<add> * hint to apply
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public Builder onReachableType(TypeReference reachableType) {
<add> this.reachableType = reachableType;
<add> return this;
<add> }
<add>
<add> /**
<add> * Use the the {@code baseName} of the resource bundle.
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public Builder baseName(String baseName) {
<add> this.baseName = baseName;
<add> return this;
<add> }
<add>
<add> /**
<add> * Creates a {@link ResourceBundleHint} based on the state of this
<add> * builder.
<add> * @return a resource bundle hint
<add> */
<add> ResourceBundleHint build() {
<add> return new ResourceBundleHint(this);
<add> }
<add>
<add> }
<add>
<ide> }
<ide><path>spring-core/src/main/java/org/springframework/aot/hint/ResourceHints.java
<ide> import java.util.function.Consumer;
<ide> import java.util.stream.Stream;
<ide>
<del>import org.springframework.aot.hint.ResourcePatternHint.Builder;
<ide> import org.springframework.lang.Nullable;
<ide>
<ide> /**
<ide> public class ResourceHints {
<ide>
<ide> private final Set<TypeReference> types;
<ide>
<del> private final List<Builder> resourcePatternHints;
<add> private final List<ResourcePatternHints> resourcePatternHints;
<ide>
<del> private final Set<String> resourceBundleHints;
<add> private final Set<ResourceBundleHint> resourceBundleHints;
<ide>
<ide>
<ide> public ResourceHints() {
<ide> public ResourceHints() {
<ide>
<ide> /**
<ide> * Return the resources that should be made available at runtime.
<del> * @return a stream of {@link ResourcePatternHint}
<add> * @return a stream of {@link ResourcePatternHints}
<ide> */
<del> public Stream<ResourcePatternHint> resourcePatterns() {
<del> Stream<ResourcePatternHint> patterns = this.resourcePatternHints.stream().map(Builder::build);
<add> public Stream<ResourcePatternHints> resourcePatterns() {
<add> Stream<ResourcePatternHints> patterns = this.resourcePatternHints.stream();
<ide> return (this.types.isEmpty() ? patterns
<ide> : Stream.concat(Stream.of(typesPatternResourceHint()), patterns));
<ide> }
<ide> public Stream<ResourcePatternHint> resourcePatterns() {
<ide> * @return a stream of {@link ResourceBundleHint}
<ide> */
<ide> public Stream<ResourceBundleHint> resourceBundles() {
<del> return this.resourceBundleHints.stream().map(ResourceBundleHint::new);
<add> return this.resourceBundleHints.stream();
<ide> }
<ide>
<ide> /**
<ide> * Register that the resources matching the specified pattern should be
<ide> * made available at runtime.
<del> * @param include a pattern of the resources to include
<ide> * @param resourceHint a builder to further customize the resource pattern
<ide> * @return {@code this}, to facilitate method chaining
<ide> */
<del> public ResourceHints registerPattern(String include, @Nullable Consumer<Builder> resourceHint) {
<del> Builder builder = new Builder().includes(include);
<add> public ResourceHints registerPattern(@Nullable Consumer<ResourcePatternHints.Builder> resourceHint) {
<add> ResourcePatternHints.Builder builder = new ResourcePatternHints.Builder();
<ide> if (resourceHint != null) {
<ide> resourceHint.accept(builder);
<ide> }
<del> this.resourcePatternHints.add(builder);
<add> this.resourcePatternHints.add(builder.build());
<ide> return this;
<ide> }
<ide>
<ide> public ResourceHints registerPattern(String include, @Nullable Consumer<Builder>
<ide> * @return {@code this}, to facilitate method chaining
<ide> */
<ide> public ResourceHints registerPattern(String include) {
<del> return registerPattern(include, null);
<add> return registerPattern(builder -> builder.includes(include));
<ide> }
<ide>
<ide> /**
<ide> public ResourceHints registerType(Class<?> type) {
<ide> * Register that the resource bundle with the specified base name should
<ide> * be made available at runtime.
<ide> * @param baseName the base name of the resource bundle
<add> * @param resourceHint a builder to further customize the resource bundle
<ide> * @return {@code this}, to facilitate method chaining
<ide> */
<del> public ResourceHints registerResourceBundle(String baseName) {
<del> this.resourceBundleHints.add(baseName);
<add> public ResourceHints registerResourceBundle(String baseName, @Nullable Consumer<ResourceBundleHint.Builder> resourceHint) {
<add> ResourceBundleHint.Builder builder = new ResourceBundleHint.Builder().baseName(baseName);
<add> if (resourceHint != null) {
<add> resourceHint.accept(builder);
<add> }
<add> this.resourceBundleHints.add(builder.build());
<ide> return this;
<ide> }
<ide>
<del> private ResourcePatternHint typesPatternResourceHint() {
<del> Builder builder = new Builder();
<add> /**
<add> * Register that the resource bundle with the specified base name should
<add> * be made available at runtime.
<add> * @param baseName the base name of the resource bundle
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public ResourceHints registerResourceBundle(String baseName) {
<add> return registerResourceBundle(baseName, null);
<add> }
<add>
<add> private ResourcePatternHints typesPatternResourceHint() {
<add> ResourcePatternHints.Builder builder = new ResourcePatternHints.Builder();
<ide> this.types.forEach(type -> builder.includes(toIncludePattern(type)));
<ide> return builder.build();
<ide> }
<ide><path>spring-core/src/main/java/org/springframework/aot/hint/ResourcePatternHint.java
<ide>
<ide> package org.springframework.aot.hint;
<ide>
<del>import java.util.ArrayList;
<del>import java.util.Arrays;
<del>import java.util.LinkedHashSet;
<del>import java.util.List;
<del>import java.util.Set;
<add>import java.util.Objects;
<add>
<add>import org.springframework.lang.Nullable;
<ide>
<ide> /**
<ide> * A hint that describes resources that should be made available at runtime.
<del> *
<ide> * <p>The patterns may be a simple path which has a one-to-one mapping to a
<ide> * resource on the classpath, or alternatively may contain the special
<ide> * {@code *} character to indicate a wildcard search.
<ide> *
<ide> * @author Stephane Nicoll
<add> * @author Brian Clozel
<ide> * @since 6.0
<ide> */
<del>public final class ResourcePatternHint {
<add>public final class ResourcePatternHint implements ConditionalHint {
<ide>
<del> private final List<String> includes;
<add> private final String pattern;
<ide>
<del> private final List<String> excludes;
<add> @Nullable
<add> private final TypeReference reachableType;
<ide>
<del>
<del> private ResourcePatternHint(Builder builder) {
<del> this.includes = new ArrayList<>(builder.includes);
<del> this.excludes = new ArrayList<>(builder.excludes);
<add> ResourcePatternHint(String pattern, @Nullable TypeReference reachableType) {
<add> this.pattern = pattern;
<add> this.reachableType = reachableType;
<ide> }
<ide>
<ide> /**
<del> * Return the include patterns to use to identify the resources to match.
<del> * @return the include patterns
<add> * Return the pattern to use for identifying the resources to match.
<add> * @return the patterns
<ide> */
<del> public List<String> getIncludes() {
<del> return this.includes;
<add> public String getPattern() {
<add> return this.pattern;
<ide> }
<ide>
<del> /**
<del> * Return the exclude patterns to use to identify the resources to match.
<del> * @return the exclude patterns
<del> */
<del> public List<String> getExcludes() {
<del> return this.excludes;
<add> @Nullable
<add> @Override
<add> public TypeReference getReachableType() {
<add> return this.reachableType;
<ide> }
<ide>
<del>
<del> /**
<del> * Builder for {@link ResourcePatternHint}.
<del> */
<del> public static class Builder {
<del>
<del> private final Set<String> includes = new LinkedHashSet<>();
<del>
<del> private final Set<String> excludes = new LinkedHashSet<>();
<del>
<del>
<del> /**
<del> * Includes the resources matching the specified pattern.
<del> * @param includes the include patterns
<del> * @return {@code this}, to facilitate method chaining
<del> */
<del> public Builder includes(String... includes) {
<del> this.includes.addAll(Arrays.asList(includes));
<del> return this;
<add> @Override
<add> public boolean equals(Object o) {
<add> if (this == o) {
<add> return true;
<ide> }
<del>
<del> /**
<del> * Exclude resources matching the specified pattern.
<del> * @param excludes the excludes pattern
<del> * @return {@code this}, to facilitate method chaining
<del> */
<del> public Builder excludes(String... excludes) {
<del> this.excludes.addAll(Arrays.asList(excludes));
<del> return this;
<del> }
<del>
<del> /**
<del> * Creates a {@link ResourcePatternHint} based on the state of this
<del> * builder.
<del> * @return a resource pattern hint
<del> */
<del> ResourcePatternHint build() {
<del> return new ResourcePatternHint(this);
<add> if (o == null || getClass() != o.getClass()) {
<add> return false;
<ide> }
<add> ResourcePatternHint that = (ResourcePatternHint) o;
<add> return this.pattern.equals(that.pattern)
<add> && Objects.equals(this.reachableType, that.reachableType);
<add> }
<ide>
<add> @Override
<add> public int hashCode() {
<add> return Objects.hash(this.pattern, this.reachableType);
<ide> }
<ide> }
<ide><path>spring-core/src/main/java/org/springframework/aot/hint/ResourcePatternHints.java
<add>/*
<add> * Copyright 2002-2022 the original author or authors.
<add> *
<add> * Licensed under the Apache License, Version 2.0 (the "License");
<add> * you may not use this file except in compliance with the License.
<add> * You may obtain a copy of the License at
<add> *
<add> * https://www.apache.org/licenses/LICENSE-2.0
<add> *
<add> * Unless required by applicable law or agreed to in writing, software
<add> * distributed under the License is distributed on an "AS IS" BASIS,
<add> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
<add> * See the License for the specific language governing permissions and
<add> * limitations under the License.
<add> */
<add>
<add>package org.springframework.aot.hint;
<add>
<add>import java.util.ArrayList;
<add>import java.util.Arrays;
<add>import java.util.LinkedHashSet;
<add>import java.util.List;
<add>import java.util.Set;
<add>
<add>/**
<add> * A collection of {@link ResourcePatternHint} describing whether
<add> * resources should be made available at runtime through a matching
<add> * mechanism or inclusion/exclusion.
<add> *
<add> * @author Stephane Nicoll
<add> * @author Brian Clozel
<add> * @since 6.0
<add> */
<add>public final class ResourcePatternHints {
<add>
<add> private final List<ResourcePatternHint> includes;
<add>
<add> private final List<ResourcePatternHint> excludes;
<add>
<add>
<add> private ResourcePatternHints(Builder builder) {
<add> this.includes = new ArrayList<>(builder.includes);
<add> this.excludes = new ArrayList<>(builder.excludes);
<add> }
<add>
<add> /**
<add> * Return the include patterns to use to identify the resources to match.
<add> * @return the include patterns
<add> */
<add> public List<ResourcePatternHint> getIncludes() {
<add> return this.includes;
<add> }
<add>
<add> /**
<add> * Return the exclude patterns to use to identify the resources to match.
<add> * @return the exclude patterns
<add> */
<add> public List<ResourcePatternHint> getExcludes() {
<add> return this.excludes;
<add> }
<add>
<add>
<add> /**
<add> * Builder for {@link ResourcePatternHints}.
<add> */
<add> public static class Builder {
<add>
<add> private final Set<ResourcePatternHint> includes = new LinkedHashSet<>();
<add>
<add> private final Set<ResourcePatternHint> excludes = new LinkedHashSet<>();
<add>
<add> /**
<add> * Includes the resources matching the specified pattern.
<add> * @param reachableType the type that should be reachable for this hint to apply
<add> * @param includes the include patterns
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public Builder includes(TypeReference reachableType, String... includes) {
<add> List<ResourcePatternHint> newIncludes = Arrays.stream(includes)
<add> .map(include -> new ResourcePatternHint(include, reachableType)).toList();
<add> this.includes.addAll(newIncludes);
<add> return this;
<add> }
<add>
<add> /**
<add> * Includes the resources matching the specified pattern.
<add> * @param includes the include patterns
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public Builder includes(String... includes) {
<add> return includes(null, includes);
<add> }
<add>
<add> /**
<add> * Exclude resources matching the specified pattern.
<add> * @param reachableType the type that should be reachable for this hint to apply
<add> * @param excludes the excludes pattern
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public Builder excludes(TypeReference reachableType, String... excludes) {
<add> List<ResourcePatternHint> newExcludes = Arrays.stream(excludes)
<add> .map(include -> new ResourcePatternHint(include, reachableType)).toList();
<add> this.excludes.addAll(newExcludes);
<add> return this;
<add> }
<add>
<add> /**
<add> * Exclude resources matching the specified pattern.
<add> * @param excludes the excludes pattern
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public Builder excludes(String... excludes) {
<add> return excludes(null, excludes);
<add> }
<add>
<add> /**
<add> * Creates a {@link ResourcePatternHints} based on the state of this
<add> * builder.
<add> * @return a resource pattern hint
<add> */
<add> ResourcePatternHints build() {
<add> return new ResourcePatternHints(this);
<add> }
<add>
<add> }
<add>}
<ide><path>spring-core/src/main/java/org/springframework/aot/hint/RuntimeHints.java
<ide> public class RuntimeHints {
<ide>
<ide> private final ResourceHints resources = new ResourceHints();
<ide>
<del> private final JavaSerializationHints javaSerialization = new JavaSerializationHints();
<add> private final SerializationHints serialization = new SerializationHints();
<ide>
<ide> private final ProxyHints proxies = new ProxyHints();
<ide>
<ide> public ResourceHints resources() {
<ide>
<ide> /**
<ide> * Provide access to serialization-based hints.
<del> * @return java serialization hints
<add> * @return serialization hints
<ide> */
<del> public JavaSerializationHints javaSerialization() {
<del> return this.javaSerialization;
<add> public SerializationHints serialization() {
<add> return this.serialization;
<ide> }
<ide>
<ide> /**
<ide><path>spring-core/src/main/java/org/springframework/aot/hint/SerializationHints.java
<add>/*
<add> * Copyright 2002-2022 the original author or authors.
<add> *
<add> * Licensed under the Apache License, Version 2.0 (the "License");
<add> * you may not use this file except in compliance with the License.
<add> * You may obtain a copy of the License at
<add> *
<add> * https://www.apache.org/licenses/LICENSE-2.0
<add> *
<add> * Unless required by applicable law or agreed to in writing, software
<add> * distributed under the License is distributed on an "AS IS" BASIS,
<add> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
<add> * See the License for the specific language governing permissions and
<add> * limitations under the License.
<add> */
<add>
<add>package org.springframework.aot.hint;
<add>
<add>import java.io.Serializable;
<add>import java.util.LinkedHashSet;
<add>import java.util.Set;
<add>import java.util.function.Consumer;
<add>import java.util.stream.Stream;
<add>
<add>import org.springframework.lang.Nullable;
<add>
<add>/**
<add> * Gather the need for Java serialization at runtime.
<add> *
<add> * @author Stephane Nicoll
<add> * @since 6.0
<add> * @see Serializable
<add> */
<add>public class SerializationHints {
<add>
<add> private final Set<JavaSerializationHint> javaSerializationHints;
<add>
<add>
<add> public SerializationHints() {
<add> this.javaSerializationHints = new LinkedHashSet<>();
<add> }
<add>
<add> /**
<add> * Return the {@link JavaSerializationHint java serialization hints} for types
<add> * that need to be serialized using Java serialization at runtime.
<add> * @return a stream of {@link JavaSerializationHint java serialization hints}
<add> */
<add> public Stream<JavaSerializationHint> javaSerialization() {
<add> return this.javaSerializationHints.stream();
<add> }
<add>
<add> /**
<add> * Register that the type defined by the specified {@link TypeReference}
<add> * need to be serialized using java serialization.
<add> * @param type the type to register
<add> * @param serializationHint a builder to further customize the serialization
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public SerializationHints registerType(TypeReference type, @Nullable Consumer<JavaSerializationHint.Builder> serializationHint) {
<add> JavaSerializationHint.Builder builder = new JavaSerializationHint.Builder(type);
<add> if (serializationHint != null) {
<add> serializationHint.accept(builder);
<add> }
<add> this.javaSerializationHints.add(builder.build());
<add> return this;
<add> }
<add>
<add> /**
<add> * Register that the type defined by the specified {@link TypeReference}
<add> * need to be serialized using java serialization.
<add> * @param type the type to register
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public SerializationHints registerType(TypeReference type) {
<add> return registerType(type, null);
<add> }
<add>
<add> /**
<add> * Register that the specified type need to be serialized using java
<add> * serialization.
<add> * @param type the type to register
<add> * @param serializationHint a builder to further customize the serialization
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public SerializationHints registerType(Class<? extends Serializable> type, @Nullable Consumer<JavaSerializationHint.Builder> serializationHint) {
<add> return registerType(TypeReference.of(type), serializationHint);
<add> }
<add>
<add> /**
<add> * Register that the specified type need to be serialized using java
<add> * serialization.
<add> * @param type the type to register
<add> * @return {@code this}, to facilitate method chaining
<add> */
<add> public SerializationHints registerType(Class<? extends Serializable> type) {
<add> return registerType(type, null);
<add> }
<add>
<add>}
<ide><path>spring-core/src/main/java/org/springframework/aot/hint/TypeHint.java
<ide> * @author Stephane Nicoll
<ide> * @since 6.0
<ide> */
<del>public final class TypeHint {
<add>public final class TypeHint implements ConditionalHint {
<ide>
<ide> private final TypeReference type;
<ide>
<ide> public TypeReference getType() {
<ide> return this.type;
<ide> }
<ide>
<del> /**
<del> * Return the type that should be reachable for this hint to apply, or
<del> * {@code null} if this hint should always been applied.
<del> * @return the reachable type, if any
<del> */
<ide> @Nullable
<add> @Override
<ide> public TypeReference getReachableType() {
<ide> return this.reachableType;
<ide> }
<ide><path>spring-core/src/main/java/org/springframework/aot/nativex/JavaSerializationHintsWriter.java
<del>/*
<del> * Copyright 2002-2022 the original author or authors.
<del> *
<del> * Licensed under the Apache License, Version 2.0 (the "License");
<del> * you may not use this file except in compliance with the License.
<del> * You may obtain a copy of the License at
<del> *
<del> * https://www.apache.org/licenses/LICENSE-2.0
<del> *
<del> * Unless required by applicable law or agreed to in writing, software
<del> * distributed under the License is distributed on an "AS IS" BASIS,
<del> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
<del> * See the License for the specific language governing permissions and
<del> * limitations under the License.
<del> */
<del>
<del>package org.springframework.aot.nativex;
<del>
<del>import java.util.LinkedHashMap;
<del>import java.util.Map;
<del>
<del>import org.springframework.aot.hint.JavaSerializationHints;
<del>import org.springframework.aot.hint.TypeReference;
<del>
<del>/**
<del> * Write a {@link JavaSerializationHints} to the JSON output expected by the
<del> * GraalVM {@code native-image} compiler, typically named
<del> * {@code serialization-config.json}.
<del> *
<del> * @author Sebastien Deleuze
<del> * @author Stephane Nicoll
<del> * @since 6.0
<del> * @see <a href="https://www.graalvm.org/22.0/reference-manual/native-image/BuildConfiguration/">Native Image Build Configuration</a>
<del> */
<del>class JavaSerializationHintsWriter {
<del>
<del> public static final JavaSerializationHintsWriter INSTANCE = new JavaSerializationHintsWriter();
<del>
<del> public void write(BasicJsonWriter writer, JavaSerializationHints hints) {
<del> writer.writeArray(hints.types().map(this::toAttributes).toList());
<del> }
<del>
<del> private Map<String, Object> toAttributes(TypeReference typeReference) {
<del> LinkedHashMap<String, Object> attributes = new LinkedHashMap<>();
<del> attributes.put("name", typeReference);
<del> return attributes;
<del> }
<del>
<del>}
<ide><path>spring-core/src/main/java/org/springframework/aot/nativex/NativeConfigurationWriter.java
<ide>
<ide> import java.util.function.Consumer;
<ide>
<del>import org.springframework.aot.hint.JavaSerializationHints;
<ide> import org.springframework.aot.hint.ProxyHints;
<ide> import org.springframework.aot.hint.ReflectionHints;
<ide> import org.springframework.aot.hint.ResourceHints;
<ide> import org.springframework.aot.hint.RuntimeHints;
<add>import org.springframework.aot.hint.SerializationHints;
<ide>
<ide> /**
<ide> * Write {@link RuntimeHints} as GraalVM native configuration.
<ide> *
<ide> * @author Sebastien Deleuze
<ide> * @author Stephane Nicoll
<ide> * @since 6.0
<del> * @see <a href="https://www.graalvm.org/22.0/reference-manual/native-image/BuildConfiguration/">Native Image Build Configuration</a>
<add> * @see <a href="https://www.graalvm.org/22.1/reference-manual/native-image/BuildConfiguration/">Native Image Build Configuration</a>
<ide> */
<ide> public abstract class NativeConfigurationWriter {
<ide>
<ide> public abstract class NativeConfigurationWriter {
<ide> * @param hints the hints to handle
<ide> */
<ide> public void write(RuntimeHints hints) {
<del> if (hints.javaSerialization().types().findAny().isPresent()) {
<del> writeJavaSerializationHints(hints.javaSerialization());
<add> if (hints.serialization().javaSerialization().findAny().isPresent()) {
<add> writeJavaSerializationHints(hints.serialization());
<ide> }
<ide> if (hints.proxies().jdkProxies().findAny().isPresent()) {
<ide> writeProxyHints(hints.proxies());
<ide> public void write(RuntimeHints hints) {
<ide> */
<ide> protected abstract void writeTo(String fileName, Consumer<BasicJsonWriter> writer);
<ide>
<del> private void writeJavaSerializationHints(JavaSerializationHints hints) {
<add> private void writeJavaSerializationHints(SerializationHints hints) {
<ide> writeTo("serialization-config.json", writer ->
<del> JavaSerializationHintsWriter.INSTANCE.write(writer, hints));
<add> SerializationHintsWriter.INSTANCE.write(writer, hints));
<ide> }
<ide>
<ide> private void writeProxyHints(ProxyHints hints) {
<ide><path>spring-core/src/main/java/org/springframework/aot/nativex/ProxyHintsWriter.java
<ide> *
<ide> * @author Sebastien Deleuze
<ide> * @author Stephane Nicoll
<add> * @author Brian Clozel
<ide> * @since 6.0
<del> * @see <a href="https://www.graalvm.org/22.0/reference-manual/native-image/DynamicProxy/">Dynamic Proxy in Native Image</a>
<del> * @see <a href="https://www.graalvm.org/22.0/reference-manual/native-image/BuildConfiguration/">Native Image Build Configuration</a>
<add> * @see <a href="https://www.graalvm.org/22.1/reference-manual/native-image/DynamicProxy/">Dynamic Proxy in Native Image</a>
<add> * @see <a href="https://www.graalvm.org/22.1/reference-manual/native-image/BuildConfiguration/">Native Image Build Configuration</a>
<ide> */
<ide> class ProxyHintsWriter {
<ide>
<ide> public void write(BasicJsonWriter writer, ProxyHints hints) {
<ide>
<ide> private Map<String, Object> toAttributes(JdkProxyHint hint) {
<ide> Map<String, Object> attributes = new LinkedHashMap<>();
<add> handleCondition(attributes, hint);
<ide> attributes.put("interfaces", hint.getProxiedInterfaces().stream()
<ide> .map(TypeReference::getCanonicalName).toList());
<ide> return attributes;
<ide> }
<ide>
<add> private void handleCondition(Map<String, Object> attributes, JdkProxyHint hint) {
<add> if (hint.getReachableType() != null) {
<add> Map<String, Object> conditionAttributes = new LinkedHashMap<>();
<add> conditionAttributes.put("typeReachable", hint.getReachableType());
<add> attributes.put("condition", conditionAttributes);
<add> }
<add> }
<add>
<ide> }
<ide><path>spring-core/src/main/java/org/springframework/aot/nativex/ResourceHintsWriter.java
<ide> import java.util.stream.Collectors;
<ide> import java.util.stream.Stream;
<ide>
<add>import org.springframework.aot.hint.ConditionalHint;
<ide> import org.springframework.aot.hint.ResourceBundleHint;
<ide> import org.springframework.aot.hint.ResourceHints;
<ide> import org.springframework.aot.hint.ResourcePatternHint;
<add>import org.springframework.aot.hint.ResourcePatternHints;
<ide> import org.springframework.lang.Nullable;
<ide>
<ide> /**
<ide> *
<ide> * @author Sebastien Deleuze
<ide> * @author Stephane Nicoll
<add> * @author Brian Clozel
<ide> * @since 6.0
<del> * @see <a href="https://www.graalvm.org/22.0/reference-manual/native-image/Resources/">Accessing Resources in Native Images</a>
<del> * @see <a href="https://www.graalvm.org/22.0/reference-manual/native-image/BuildConfiguration/">Native Image Build Configuration</a>
<add> * @see <a href="https://www.graalvm.org/22.1/reference-manual/native-image/Resources/">Accessing Resources in Native Images</a>
<add> * @see <a href="https://www.graalvm.org/22.1/reference-manual/native-image/BuildConfiguration/">Native Image Build Configuration</a>
<ide> */
<ide> class ResourceHintsWriter {
<ide>
<ide> public void write(BasicJsonWriter writer, ResourceHints hints) {
<ide>
<ide> private Map<String, Object> toAttributes(ResourceHints hint) {
<ide> Map<String, Object> attributes = new LinkedHashMap<>();
<del> addIfNotEmpty(attributes, "includes", hint.resourcePatterns().map(ResourcePatternHint::getIncludes)
<add> addIfNotEmpty(attributes, "includes", hint.resourcePatterns().map(ResourcePatternHints::getIncludes)
<ide> .flatMap(List::stream).distinct().map(this::toAttributes).toList());
<del> addIfNotEmpty(attributes, "excludes", hint.resourcePatterns().map(ResourcePatternHint::getExcludes)
<add> addIfNotEmpty(attributes, "excludes", hint.resourcePatterns().map(ResourcePatternHints::getExcludes)
<ide> .flatMap(List::stream).distinct().map(this::toAttributes).toList());
<ide> return attributes;
<ide> }
<ide> private void handleResourceBundles(Map<String, Object> attributes, Stream<Resour
<ide>
<ide> private Map<String, Object> toAttributes(ResourceBundleHint hint) {
<ide> Map<String, Object> attributes = new LinkedHashMap<>();
<add> handleCondition(attributes, hint);
<ide> attributes.put("name", hint.getBaseName());
<ide> return attributes;
<ide> }
<ide>
<del> private Map<String, Object> toAttributes(String pattern) {
<add> private Map<String, Object> toAttributes(ResourcePatternHint hint) {
<ide> Map<String, Object> attributes = new LinkedHashMap<>();
<del> attributes.put("pattern", patternToRegexp(pattern));
<add> handleCondition(attributes, hint);
<add> attributes.put("pattern", patternToRegexp(hint.getPattern()));
<ide> return attributes;
<ide> }
<ide>
<ide> else if (value != null) {
<ide> }
<ide> }
<ide>
<add> private void handleCondition(Map<String, Object> attributes, ConditionalHint hint) {
<add> if (hint.getReachableType() != null) {
<add> Map<String, Object> conditionAttributes = new LinkedHashMap<>();
<add> conditionAttributes.put("typeReachable", hint.getReachableType());
<add> attributes.put("condition", conditionAttributes);
<add> }
<add> }
<add>
<ide> }
<ide><path>spring-core/src/main/java/org/springframework/aot/nativex/SerializationHintsWriter.java
<add>/*
<add> * Copyright 2002-2022 the original author or authors.
<add> *
<add> * Licensed under the Apache License, Version 2.0 (the "License");
<add> * you may not use this file except in compliance with the License.
<add> * You may obtain a copy of the License at
<add> *
<add> * https://www.apache.org/licenses/LICENSE-2.0
<add> *
<add> * Unless required by applicable law or agreed to in writing, software
<add> * distributed under the License is distributed on an "AS IS" BASIS,
<add> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
<add> * See the License for the specific language governing permissions and
<add> * limitations under the License.
<add> */
<add>
<add>package org.springframework.aot.nativex;
<add>
<add>import java.util.LinkedHashMap;
<add>import java.util.Map;
<add>
<add>import org.springframework.aot.hint.ConditionalHint;
<add>import org.springframework.aot.hint.JavaSerializationHint;
<add>import org.springframework.aot.hint.SerializationHints;
<add>
<add>/**
<add> * Write a {@link SerializationHints} to the JSON output expected by the
<add> * GraalVM {@code native-image} compiler, typically named
<add> * {@code serialization-config.json}.
<add> *
<add> * @author Sebastien Deleuze
<add> * @author Stephane Nicoll
<add> * @author Brian Clozel
<add> * @since 6.0
<add> * @see <a href="https://www.graalvm.org/22.1/reference-manual/native-image/BuildConfiguration/">Native Image Build Configuration</a>
<add> */
<add>class SerializationHintsWriter {
<add>
<add> public static final SerializationHintsWriter INSTANCE = new SerializationHintsWriter();
<add>
<add> public void write(BasicJsonWriter writer, SerializationHints hints) {
<add> writer.writeArray(hints.javaSerialization().map(this::toAttributes).toList());
<add> }
<add>
<add> private Map<String, Object> toAttributes(JavaSerializationHint serializationHint) {
<add> LinkedHashMap<String, Object> attributes = new LinkedHashMap<>();
<add> handleCondition(attributes, serializationHint);
<add> attributes.put("name", serializationHint.getType());
<add> return attributes;
<add> }
<add>
<add> private void handleCondition(Map<String, Object> attributes, ConditionalHint hint) {
<add> if (hint.getReachableType() != null) {
<add> Map<String, Object> conditionAttributes = new LinkedHashMap<>();
<add> conditionAttributes.put("typeReachable", hint.getReachableType());
<add> attributes.put("condition", conditionAttributes);
<add> }
<add> }
<add>
<add>}
<ide><path>spring-core/src/test/java/org/springframework/aot/hint/ClassProxyHintTests.java
<ide> * Tests for {@link ClassProxyHint}.
<ide> *
<ide> * @author Stephane Nicoll
<add> * @author Brian Clozel
<ide> */
<ide> class ClassProxyHintTests {
<ide>
<ide> @Test
<del> void equalsWithWithSameInstanceIsTrue() {
<add> void equalsWithSameInstanceIsTrue() {
<ide> ClassProxyHint hint = ClassProxyHint.of(Properties.class).build();
<ide> assertThat(hint).isEqualTo(hint);
<ide> }
<ide>
<ide> @Test
<del> void equalsWithWithSameTargetClassIsTrue() {
<add> void equalsWithSameTargetClassIsTrue() {
<ide> ClassProxyHint first = ClassProxyHint.of(Properties.class).build();
<ide> ClassProxyHint second = ClassProxyHint.of(TypeReference.of(Properties.class)).build();
<ide> assertThat(first).isEqualTo(second);
<ide> }
<ide>
<ide> @Test
<del> void equalsWithWithSameProxiedInterfacesIsTrue() {
<add> void equalsWithSameProxiedInterfacesIsTrue() {
<ide> ClassProxyHint first = ClassProxyHint.of(Properties.class)
<ide> .proxiedInterfaces(Serializable.class).build();
<ide> ClassProxyHint second = ClassProxyHint.of(Properties.class)
<ide> void equalsWithWithSameProxiedInterfacesIsTrue() {
<ide> }
<ide>
<ide> @Test
<del> void equalsWithWithDifferentTargetClassIsFalse() {
<add> void equalsWithDifferentTargetClassIsFalse() {
<ide> ClassProxyHint first = ClassProxyHint.of(Properties.class).build();
<ide> ClassProxyHint second = ClassProxyHint.of(Hashtable.class).build();
<ide> assertThat(first).isNotEqualTo(second);
<ide> }
<ide>
<ide> @Test
<del> void equalsWithWithSameProxiedInterfacesDifferentOrderIsFalse() {
<add> void equalsWithSameProxiedInterfacesDifferentOrderIsFalse() {
<ide> ClassProxyHint first = ClassProxyHint.of(Properties.class)
<ide> .proxiedInterfaces(Serializable.class, Closeable.class).build();
<ide> ClassProxyHint second = ClassProxyHint.of(Properties.class)
<ide> void equalsWithWithSameProxiedInterfacesDifferentOrderIsFalse() {
<ide> }
<ide>
<ide> @Test
<del> void equalsWithWithDifferentProxiedInterfacesIsFalse() {
<add> void equalsWithDifferentProxiedInterfacesIsFalse() {
<ide> ClassProxyHint first = ClassProxyHint.of(Properties.class)
<ide> .proxiedInterfaces(Serializable.class).build();
<ide> ClassProxyHint second = ClassProxyHint.of(Properties.class)
<ide> void equalsWithNonClassProxyHintIsFalse() {
<ide> assertThat(first).isNotEqualTo(second);
<ide> }
<ide>
<add> @Test
<add> void equalsWithDifferentConditionIsFalse() {
<add> ClassProxyHint first = ClassProxyHint.of(Properties.class).build();
<add> ClassProxyHint second = ClassProxyHint.of(Properties.class).onReachableType(TypeReference.of("org.example.test")).build();
<add> assertThat(first).isNotEqualTo(second);
<add> }
<add>
<ide> }
<ide><path>spring-core/src/test/java/org/springframework/aot/hint/JdkProxyHintTests.java
<ide> class JdkProxyHintTests {
<ide>
<ide> @Test
<del> void equalsWithWithSameInstanceIsTrue() {
<add> void equalsWithSameInstanceIsTrue() {
<ide> JdkProxyHint hint = new Builder().proxiedInterfaces(Function.class, Consumer.class).build();
<ide> assertThat(hint).isEqualTo(hint);
<ide> }
<ide>
<ide> @Test
<del> void equalsWithWithSameProxiedInterfacesIsTrue() {
<add> void equalsWithSameProxiedInterfacesIsTrue() {
<ide> JdkProxyHint first = new Builder().proxiedInterfaces(Function.class, Consumer.class).build();
<ide> JdkProxyHint second = new Builder().proxiedInterfaces(TypeReference.of(Function.class.getName()),
<ide> TypeReference.of(Consumer.class)).build();
<ide> assertThat(first).isEqualTo(second);
<ide> }
<ide>
<ide> @Test
<del> void equalsWithWithSameProxiedInterfacesDifferentOrderIsFalse() {
<add> void equalsWithSameProxiedInterfacesAndDifferentConditionIsFalse() {
<add> JdkProxyHint first = new Builder().proxiedInterfaces(Function.class, Consumer.class)
<add> .onReachableType(TypeReference.of(String.class)).build();
<add> JdkProxyHint second = new Builder().proxiedInterfaces(TypeReference.of(Function.class.getName()),
<add> TypeReference.of(Consumer.class)).onReachableType(TypeReference.of(Function.class)).build();
<add> assertThat(first).isNotEqualTo(second);
<add> }
<add>
<add> @Test
<add> void equalsWithSameProxiedInterfacesDifferentOrderIsFalse() {
<ide> JdkProxyHint first = new Builder().proxiedInterfaces(Function.class, Consumer.class).build();
<ide> JdkProxyHint second = new Builder().proxiedInterfaces(TypeReference.of(Consumer.class),
<ide> TypeReference.of(Function.class.getName())).build();
<ide> assertThat(first).isNotEqualTo(second);
<ide> }
<ide>
<ide> @Test
<del> void equalsWithWithDifferentProxiedInterfacesIsFalse() {
<add> void equalsWithDifferentProxiedInterfacesIsFalse() {
<ide> JdkProxyHint first = new Builder().proxiedInterfaces(Function.class).build();
<ide> JdkProxyHint second = new Builder().proxiedInterfaces(TypeReference.of(Function.class.getName()),
<ide> TypeReference.of(Consumer.class)).build();
<ide><path>spring-core/src/test/java/org/springframework/aot/hint/ResourceHintsTests.java
<ide> void registerPattern() {
<ide>
<ide> @Test
<ide> void registerPatternWithIncludesAndExcludes() {
<del> this.resourceHints.registerPattern("com/example/*.properties",
<del> resourceHint -> resourceHint.excludes("com/example/to-ignore.properties"));
<add> this.resourceHints.registerPattern(resourceHint ->
<add> resourceHint.includes("com/example/*.properties").excludes("com/example/to-ignore.properties"));
<ide> assertThat(this.resourceHints.resourcePatterns()).singleElement().satisfies(patternOf(
<ide> List.of("com/example/*.properties"),
<ide> List.of("com/example/to-ignore.properties")));
<ide> void registerResourceBundleSeveralTimesAddsOneEntry() {
<ide> }
<ide>
<ide>
<del> private Consumer<ResourcePatternHint> patternOf(String... includes) {
<add> private Consumer<ResourcePatternHints> patternOf(String... includes) {
<ide> return patternOf(Arrays.asList(includes), Collections.emptyList());
<ide> }
<ide>
<ide> private Consumer<ResourceBundleHint> resourceBundle(String baseName) {
<ide> return resourceBundleHint -> assertThat(resourceBundleHint.getBaseName()).isEqualTo(baseName);
<ide> }
<ide>
<del> private Consumer<ResourcePatternHint> patternOf(List<String> includes, List<String> excludes) {
<add> private Consumer<ResourcePatternHints> patternOf(List<String> includes, List<String> excludes) {
<ide> return pattern -> {
<del> assertThat(pattern.getIncludes()).containsExactlyElementsOf(includes);
<del> assertThat(pattern.getExcludes()).containsExactlyElementsOf(excludes);
<add> assertThat(pattern.getIncludes()).map(ResourcePatternHint::getPattern).containsExactlyElementsOf(includes);
<add> assertThat(pattern.getExcludes()).map(ResourcePatternHint::getPattern).containsExactlyElementsOf(excludes);
<ide> };
<ide> }
<ide>
<ide><path>spring-core/src/test/java/org/springframework/aot/hint/RuntimeHintsTests.java
<ide> void reflectionHintWithClass() {
<ide> void resourceHintWithClass() {
<ide> this.hints.resources().registerType(String.class);
<ide> assertThat(this.hints.resources().resourcePatterns()).singleElement().satisfies(resourceHint -> {
<del> assertThat(resourceHint.getIncludes()).containsExactly("java/lang/String.class");
<add> assertThat(resourceHint.getIncludes()).map(ResourcePatternHint::getPattern).containsExactly("java/lang/String.class");
<ide> assertThat(resourceHint.getExcludes()).isEmpty();
<ide> });
<ide> }
<ide>
<ide> @Test
<ide> void javaSerializationHintWithClass() {
<del> this.hints.javaSerialization().registerType(String.class);
<del> assertThat(this.hints.javaSerialization().types()).containsExactly(TypeReference.of(String.class));
<add> this.hints.serialization().registerType(String.class);
<add> assertThat(this.hints.serialization().javaSerialization().map(JavaSerializationHint::getType))
<add> .containsExactly(TypeReference.of(String.class));
<ide> }
<ide>
<ide> @Test
<add><path>spring-core/src/test/java/org/springframework/aot/hint/SerializationHintsTests.java
<del><path>spring-core/src/test/java/org/springframework/aot/hint/JavaSerializationHintsTests.java
<ide> import static org.assertj.core.api.Assertions.assertThat;
<ide>
<ide> /**
<del> * Tests for {@link JavaSerializationHints}.
<add> * Tests for {@link SerializationHints}.
<ide> *
<ide> * @author Stephane Nicoll
<ide> */
<del>class JavaSerializationHintsTests {
<add>class SerializationHintsTests {
<ide>
<del> private final JavaSerializationHints javaSerializationHints = new JavaSerializationHints();
<add> private final SerializationHints serializationHints = new SerializationHints();
<ide>
<ide> @Test
<ide> void registerTypeTwiceExposesOneHint() {
<del> this.javaSerializationHints.registerType(URL.class);
<del> this.javaSerializationHints.registerType(TypeReference.of(URL.class.getName()));
<del> assertThat(this.javaSerializationHints.types()).singleElement()
<del> .isEqualTo(TypeReference.of(URL.class));
<add> this.serializationHints.registerType(URL.class);
<add> this.serializationHints.registerType(TypeReference.of(URL.class.getName()));
<add> assertThat(this.serializationHints.javaSerialization()).singleElement()
<add> .extracting(JavaSerializationHint::getType).isEqualTo(TypeReference.of(URL.class));
<ide> }
<ide>
<ide> }
<ide><path>spring-core/src/test/java/org/springframework/aot/nativex/FileNativeConfigurationWriterTests.java
<ide> import org.skyscreamer.jsonassert.JSONCompareMode;
<ide>
<ide> import org.springframework.aot.hint.ExecutableMode;
<del>import org.springframework.aot.hint.JavaSerializationHints;
<ide> import org.springframework.aot.hint.MemberCategory;
<ide> import org.springframework.aot.hint.ProxyHints;
<ide> import org.springframework.aot.hint.ReflectionHints;
<ide> import org.springframework.aot.hint.ResourceHints;
<ide> import org.springframework.aot.hint.RuntimeHints;
<add>import org.springframework.aot.hint.SerializationHints;
<ide> import org.springframework.aot.hint.TypeReference;
<ide> import org.springframework.core.codec.StringDecoder;
<ide> import org.springframework.util.MimeType;
<ide> void emptyConfig() {
<ide> void serializationConfig() throws IOException, JSONException {
<ide> FileNativeConfigurationWriter generator = new FileNativeConfigurationWriter(tempDir);
<ide> RuntimeHints hints = new RuntimeHints();
<del> JavaSerializationHints serializationHints = hints.javaSerialization();
<add> SerializationHints serializationHints = hints.serialization();
<ide> serializationHints.registerType(Integer.class);
<ide> serializationHints.registerType(Long.class);
<ide> generator.write(hints);
<ide><path>spring-core/src/test/java/org/springframework/aot/nativex/ProxyHintsWriterTests.java
<ide> import org.skyscreamer.jsonassert.JSONCompareMode;
<ide>
<ide> import org.springframework.aot.hint.ProxyHints;
<add>import org.springframework.aot.hint.TypeReference;
<ide>
<ide> /**
<ide> * Tests for {@link ProxyHintsWriter}.
<ide> void empty() throws JSONException {
<ide> }
<ide>
<ide> @Test
<del> void one() throws JSONException {
<add> void shouldWriteOneEntry() throws JSONException {
<ide> ProxyHints hints = new ProxyHints();
<ide> hints.registerJdkProxy(Function.class);
<ide> assertEquals("""
<ide> void one() throws JSONException {
<ide> }
<ide>
<ide> @Test
<del> void two() throws JSONException {
<add> void shouldWriteMultipleEntries() throws JSONException {
<ide> ProxyHints hints = new ProxyHints();
<ide> hints.registerJdkProxy(Function.class);
<ide> hints.registerJdkProxy(Function.class, Consumer.class);
<ide> void two() throws JSONException {
<ide> ]""", hints);
<ide> }
<ide>
<add> @Test
<add> void shouldWriteCondition() throws JSONException {
<add> ProxyHints hints = new ProxyHints();
<add> hints.registerJdkProxy(builder -> builder.proxiedInterfaces(Function.class)
<add> .onReachableType(TypeReference.of("org.example.Test")));
<add> assertEquals("""
<add> [
<add> { "condition": { "typeReachable": "org.example.Test"}, "interfaces": [ "java.util.function.Function" ] }
<add> ]""", hints);
<add> }
<add>
<ide> private void assertEquals(String expectedString, ProxyHints hints) throws JSONException {
<ide> StringWriter out = new StringWriter();
<ide> BasicJsonWriter writer = new BasicJsonWriter(out, "\t");
<ide><path>spring-core/src/test/java/org/springframework/aot/nativex/ResourceHintsWriterTests.java
<ide> import org.skyscreamer.jsonassert.JSONCompareMode;
<ide>
<ide> import org.springframework.aot.hint.ResourceHints;
<add>import org.springframework.aot.hint.TypeReference;
<ide>
<ide> /**
<ide> * Tests for {@link ResourceHintsWriter}.
<ide> *
<ide> * @author Sebastien Deleuze
<add> * @author Brian Clozel
<ide> */
<ide> public class ResourceHintsWriterTests {
<ide>
<ide> void registerPattern() throws JSONException {
<ide> @Test
<ide> void registerPatternWithIncludesAndExcludes() throws JSONException {
<ide> ResourceHints hints = new ResourceHints();
<del> hints.registerPattern("com/example/*.properties", hint -> hint.excludes("com/example/to-ignore.properties"));
<del> hints.registerPattern("org/example/*.properties", hint -> hint.excludes("org/example/to-ignore.properties"));
<add> hints.registerPattern(hint -> hint.includes("com/example/*.properties").excludes("com/example/to-ignore.properties"));
<add> hints.registerPattern(hint -> hint.includes("org/other/*.properties").excludes("org/other/to-ignore.properties"));
<ide> assertEquals("""
<ide> {
<ide> "resources": {
<ide> "includes": [
<ide> { "pattern": "\\\\Qcom/example/\\\\E.*\\\\Q.properties\\\\E"},
<del> { "pattern": "\\\\Qorg/example/\\\\E.*\\\\Q.properties\\\\E"}
<add> { "pattern": "\\\\Qorg/other/\\\\E.*\\\\Q.properties\\\\E"}
<ide> ],
<ide> "excludes": [
<ide> { "pattern": "\\\\Qcom/example/to-ignore.properties\\\\E"},
<del> { "pattern": "\\\\Qorg/example/to-ignore.properties\\\\E"}
<add> { "pattern": "\\\\Qorg/other/to-ignore.properties\\\\E"}
<add> ]
<add> }
<add> }""", hints);
<add> }
<add>
<add> @Test
<add> void registerWithReachableTypeCondition() throws JSONException {
<add> ResourceHints hints = new ResourceHints();
<add> hints.registerPattern(builder -> builder.includes(TypeReference.of("com.example.Test"), "com/example/test.properties"));
<add> assertEquals("""
<add> {
<add> "resources": {
<add> "includes": [
<add> { "condition": { "typeReachable": "com.example.Test"}, "pattern": "\\\\Qcom/example/test.properties\\\\E"}
<ide> ]
<ide> }
<ide> }""", hints);
<add><path>spring-core/src/test/java/org/springframework/aot/nativex/SerializationHintsWriterTests.java
<del><path>spring-core/src/test/java/org/springframework/aot/nativex/JavaSerializationHintsWriterTests.java
<ide> import org.skyscreamer.jsonassert.JSONAssert;
<ide> import org.skyscreamer.jsonassert.JSONCompareMode;
<ide>
<del>import org.springframework.aot.hint.JavaSerializationHints;
<add>import org.springframework.aot.hint.SerializationHints;
<ide> import org.springframework.aot.hint.TypeReference;
<ide> import org.springframework.core.env.Environment;
<ide>
<ide> /**
<del> * Tests for {@link JavaSerializationHintsWriter}.
<add> * Tests for {@link SerializationHintsWriter}.
<ide> *
<ide> * @author Sebastien Deleuze
<ide> */
<del>public class JavaSerializationHintsWriterTests {
<add>public class SerializationHintsWriterTests {
<ide>
<ide> @Test
<del> void empty() throws JSONException {
<del> JavaSerializationHints hints = new JavaSerializationHints();
<add> void shouldWriteEmptyHint() throws JSONException {
<add> SerializationHints hints = new SerializationHints();
<ide> assertEquals("[]", hints);
<ide> }
<ide>
<ide> @Test
<del> void one() throws JSONException {
<del> JavaSerializationHints hints = new JavaSerializationHints().registerType(TypeReference.of(String.class));
<add> void shouldWriteSingleHint() throws JSONException {
<add> SerializationHints hints = new SerializationHints().registerType(TypeReference.of(String.class));
<ide> assertEquals("""
<ide> [
<ide> { "name": "java.lang.String" }
<ide> ]""", hints);
<ide> }
<ide>
<ide> @Test
<del> void two() throws JSONException {
<del> JavaSerializationHints hints = new JavaSerializationHints()
<add> void shouldWriteMultipleHints() throws JSONException {
<add> SerializationHints hints = new SerializationHints()
<ide> .registerType(TypeReference.of(String.class))
<ide> .registerType(TypeReference.of(Environment.class));
<ide> assertEquals("""
<ide> void two() throws JSONException {
<ide> ]""", hints);
<ide> }
<ide>
<del> private void assertEquals(String expectedString, JavaSerializationHints hints) throws JSONException {
<add> @Test
<add> void shouldWriteSingleHintWithCondition() throws JSONException {
<add> SerializationHints hints = new SerializationHints().registerType(TypeReference.of(String.class),
<add> builder -> builder.onReachableType(TypeReference.of("org.example.Test")));
<add> assertEquals("""
<add> [
<add> { "condition": { "typeReachable": "org.example.Test" }, "name": "java.lang.String" }
<add> ]""", hints);
<add> }
<add>
<add> private void assertEquals(String expectedString, SerializationHints hints) throws JSONException {
<ide> StringWriter out = new StringWriter();
<ide> BasicJsonWriter writer = new BasicJsonWriter(out, "\t");
<del> JavaSerializationHintsWriter.INSTANCE.write(writer, hints);
<add> SerializationHintsWriter.INSTANCE.write(writer, hints);
<ide> JSONAssert.assertEquals(expectedString, out.toString(), JSONCompareMode.NON_EXTENSIBLE);
<ide> }
<ide>
<ide><path>spring-core/src/test/java/org/springframework/core/io/support/SpringFactoriesLoaderRuntimeHintsRegistrarTests.java
<ide> import org.junit.jupiter.api.Test;
<ide>
<ide> import org.springframework.aot.hint.MemberCategory;
<add>import org.springframework.aot.hint.ResourcePatternHint;
<ide> import org.springframework.aot.hint.RuntimeHints;
<ide> import org.springframework.aot.hint.RuntimeHintsRegistrar;
<ide> import org.springframework.aot.hint.TypeHint;
<ide> void setup() {
<ide> @Test
<ide> void resourceLocationHasHints() {
<ide> assertThat(this.hints.resources().resourcePatterns())
<del> .anySatisfy(hint -> assertThat(hint.getIncludes())
<add> .anySatisfy(hint -> assertThat(hint.getIncludes()).map(ResourcePatternHint::getPattern)
<ide> .contains(SpringFactoriesLoader.FACTORIES_RESOURCE_LOCATION));
<ide> }
<ide> | 29 |
Text | Text | add model card for electra-base-german-uncased | 3c72f5584b410f5f53bea300b4e092e43955c300 | <ide><path>model_cards/german-nlp-group/electra-base-german-uncased/README.md
<add>---
<add>language: de
<add>license: mit
<add>thumbnail: "https://raw.githubusercontent.com/German-NLP-Group/german-transformer-training/master/model_cards/german-electra-logo.png"
<add>tags:
<add>- electra
<add>- commoncrawl
<add>- uncased
<add>- umlaute
<add>---
<add>
<add># German Electra Uncased
<add><img width="300px" src="https://raw.githubusercontent.com/German-NLP-Group/german-transformer-training/master/model_cards/german-electra-logo.png">
<add>[¹]
<add>
<add>
<add># Model Info
<add>
<add>This Model is suitable for Training on many downstream tasks in German (Q&A, Sentiment Analysis, etc.).
<add>
<add>It can be used as a drop-in Replacement for **BERT** in most down-stream tasks (**ELECTRA** is even implemented as an extended **BERT** Class).
<add>
<add>On the time of the realse (August 2020) this Model is the best performing publicly available German NLP Model on various German Evaluation Metrics (CONLL, GermEval19 Coarse, GermEval19 Fine).
<add>
<add>## Installation
<add>
<add>---
<add>This model is **uncased** but does not use **strip accents**.
<add>The necessary parameter is `strip_accents=False`.
<add>
<add>This needs to be set for the tokenizer otherwise the model will perform slightly worse.
<add>It was added to Transformers with [PR #6280](https://github.com/huggingface/transformers/pull/6280).
<add>
<add>Since Transformers has not been released since the PR #6280 was merged, you have to install directly from source:
<add>
<add>`pip install git+https://github.com/huggingface/transformers.git -U`
<add>
<add>---
<add>
<add>
<add>## Uncase and Umlauts ('Ö', 'Ä', 'Ü')
<add>This model is uncased. This helps especially for domains where colloquial terms with uncorrect capitalization is often used.
<add>
<add>The special characters 'ö', 'ü', 'ä' are included through the `strip_accent=False` option, as this leads to an improved precision.
<add>
<add>## Creators
<add>This model was trained and open sourced in conjunction with the [**German NLP Group**](https://github.com/German-NLP-Group) in equal parts by:
<add>- [**Philip May**](https://eniak.de) - [T-Systems on site services GmbH](https://www.t-systems-onsite.de/)
<add>- [**Philipp Reißel**](https://www.reissel.eu) - [ambeRoad](https://amberoad.de/)
<add>
<add>## Evaluation: GermEval18 Coarse
<add>
<add>| Model Name |</br>F1 macro<br/> Mean | </br>F1 macro<br/>Median | </br>F1 macro<br/>Std |
<add>|---|---|---|---|
<add>| <span style="color:red">**ELECTRA-base-german-uncased** (this model) | <span style="color:red">**0.778** | **0.778** | **0.00392** |
<add>| dbmdz/bert-base-german-uncased | 0.770 | 0.770 | 0.00572 |
<add>| dbmdz/bert-base-german-cased | 0.765 | 0.765 | 0.00523 |
<add>| bert-base-german-cased | 0.762 | 0.761 | 0.00597 |
<add>| distilbert-base-german-cased | 0.752 | 0.752 | 0.00341 |
<add>| dbmdz/electra-base-german-europeana-cased-discriminator | 0.745 | 0.745 | 0.00498 |
<add>| dbmdz-bert-base-german-europeana-uncased | 0.736 | 0.737 | 0.00476 |
<add>| dbmdz-bert-base-german-europeana-cased | 0.727 | 0.729 | 0.00674 |
<add>
<add>- (1): Hyperparameters taken from the [FARM project](https://farm.deepset.ai/) "[germEval18Coarse_config.json](https://github.com/deepset-ai/FARM/blob/master/experiments/german-bert2.0-eval/germEval18Coarse_config.json)"
<add>
<add>
<add>
<add>## Checkpoint evaluation
<add>Since it it not guaranteed that the last checkpoint is the best, we evaluated the checkpoints on GermEval18. We found that the last checkpoint is indeed the best. The training was stable and did not overfit the text corpus. Below is a boxplot chart showing the different checkpoints.
<add>
<add>
<add>
<add>## Pre-training details
<add>
<add>### Data
<add>- Cleaned Common Crawl Corpus 2019-09 German: [CC_net](https://github.com/facebookresearch/cc_net) (Only head coprus and filtered for language_score > 0.98) - 62 GB
<add>- German Wikipedia Article Pages Dump (20200701) - 5.5 GB
<add>- German Wikipedia Talk Pages Dump (20200620) - 1.1 GB
<add>- Subtitles - 823 MB
<add>- News 2018 - 4.1 GB
<add>
<add>The sentences were split with [SojaMo](https://github.com/tsproisl/SoMaJo). We took the German Wikipedia Article Pages Dump 3x to oversample. This approach was also used in a similar way in GPT-3 (Table 2.2).
<add>
<add>More Details can be found here [Preperaing Datasets for German Electra Github](https://github.com/German-NLP-Group/german-transformer-training)
<add>
<add>### Electra Branch no_strip_accents
<add>Because we do not want to stip accents in our training data we made a change to Electra and used this repo [Electra no_strip_accents](https://github.com/PhilipMay/electra/tree/no_strip_accents) (branch `no_strip_accents`). Then created the tf dataset with:
<add>
<add>```bash
<add>python build_pretraining_dataset.py --corpus-dir <corpus_dir> --vocab-file <dir>/vocab.txt --output-dir ./tf_data --max-seq-length 512 --num-processes 8 --do-lower-case --no-strip-accents
<add>```
<add>
<add>## The training
<add>
<add>The training itself can be performed with the Original Electra Repo (No special case for this needed).
<add>We run it with the following Config:
<add>
<add>
<add><details>
<add> <summary>The exact Training Config</summary>
<add><br/>debug False
<add><br/>disallow_correct False
<add><br/>disc_weight 50.0
<add><br/>do_eval False
<add><br/>do_lower_case True
<add><br/>do_train True
<add><br/>electra_objective True
<add><br/>embedding_size 768
<add><br/>eval_batch_size 128
<add><br/>gcp_project None
<add><br/>gen_weight 1.0
<add><br/>generator_hidden_size 0.33333
<add><br/>generator_layers 1.0
<add><br/>iterations_per_loop 200
<add><br/>keep_checkpoint_max 0
<add><br/>learning_rate 0.0002
<add><br/>lr_decay_power 1.0
<add><br/>mask_prob 0.15
<add><br/>max_predictions_per_seq 79
<add><br/>max_seq_length 512
<add><br/>model_dir gs://XXX
<add><br/>model_hparam_overrides {}
<add><br/>model_name 02_Electra_Checkpoints_32k_766k_Combined
<add><br/>model_size base
<add><br/>num_eval_steps 100
<add><br/>num_tpu_cores 8
<add><br/>num_train_steps 766000
<add><br/>num_warmup_steps 10000
<add><br/>pretrain_tfrecords gs://XXX
<add><br/>results_pkl gs://XXX
<add><br/>results_txt gs://XXX
<add><br/>save_checkpoints_steps 5000
<add><br/>temperature 1.0
<add><br/>tpu_job_name None
<add><br/>tpu_name electrav5
<add><br/>tpu_zone None
<add><br/>train_batch_size 256
<add><br/>uniform_generator False
<add><br/>untied_generator True
<add><br/>untied_generator_embeddings False
<add><br/>use_tpu True
<add><br/>vocab_file gs://XXX
<add><br/>vocab_size 32767
<add><br/>weight_decay_rate 0.01
<add>
<add> </details>
<add>
<add>
<add>
<add>Please Note: *Due to the GAN like strucutre of Electra the loss is not that meaningful*
<add>
<add>It took about 7 Days on a preemtible TPU V3-8. In total, the Model went through approximately 10 Epochs. For an automatically recreation of a cancelled TPUs we used [tpunicorn](https://github.com/shawwn/tpunicorn). The total cost of training summed up to about 450 $ for one run. The Data-pre processing and Vocab Creation needed approximately 500-1000 CPU hours. Servers were fully provided by [T-Systems on site services GmbH](https://www.t-systems-onsite.de/), [ambeRoad](https://amberoad.de/).
<add>Special thanks to [Stefan Schweter](https://github.com/stefan-it) for your feedback and providing parts of the text corpus.
<add>
<add>[¹]: Source for the picture [Pinterest](https://www.pinterest.cl/pin/371828512984142193/)
<add>
<add>## Negative Results
<add>We tried the following approaches which we found had no positive influence:
<add>
<add>- **Increased Vocab Size**: Leads to more parameters and thus reduced examples/sec while no visible Performance gains were measured
<add>- **Decreased Batch-Size**: The original Electra was trained with a Batch Size per TPU Core of 16 whereas this Model was trained with 32 BS / TPU Core. We found out that 32 BS leads to better results when you compare metrics over computation time
<add> | 1 |
Javascript | Javascript | avoid memory leak in v8 ics after (de)serializing | 2696446edfaf7fd2060e57ac35c4237d191fbb23 | <ide><path>lib/serialization/ObjectMiddleware.js
<ide> class ObjectMiddleware extends SerializerMiddleware {
<ide> */
<ide> serialize(data, context) {
<ide> /** @type {any[]} */
<del> const result = [CURRENT_VERSION];
<add> let result = [CURRENT_VERSION];
<ide> let currentPos = 0;
<del> const referenceable = new Map();
<add> let referenceable = new Map();
<ide> const addReferenceable = item => {
<ide> referenceable.set(item, currentPos++);
<ide> };
<del> const bufferDedupeMap = new Map();
<add> let bufferDedupeMap = new Map();
<ide> const dedupeBuffer = buf => {
<ide> const len = buf.length;
<ide> const entry = bufferDedupeMap.get(len);
<ide> class ObjectMiddleware extends SerializerMiddleware {
<ide> }
<ide> };
<ide> let currentPosTypeLookup = 0;
<del> const objectTypeLookup = new Map();
<add> let objectTypeLookup = new Map();
<ide> const cycleStack = new Set();
<ide> const stackToString = item => {
<ide> const arr = Array.from(cycleStack);
<ide> class ObjectMiddleware extends SerializerMiddleware {
<ide> .join(" -> ");
<ide> };
<ide> let hasDebugInfoAttached;
<del> const ctx = {
<add> let ctx = {
<ide> write(value, key) {
<ide> try {
<ide> process(value);
<ide> class ObjectMiddleware extends SerializerMiddleware {
<ide> for (const item of data) {
<ide> process(item);
<ide> }
<add> return result;
<ide> } catch (e) {
<ide> if (e === NOT_SERIALIZABLE) return null;
<ide>
<ide> throw e;
<add> } finally {
<add> // Get rid of these references to avoid leaking memory
<add> // This happens because the optimized code v8 generates
<add> // is optimized for our "ctx.write" method so it will reference
<add> // it from e. g. Dependency.prototype.serialize -(IC)-> ctx.write
<add> data = result = referenceable = bufferDedupeMap = objectTypeLookup = ctx = undefined;
<ide> }
<del>
<del> return result;
<ide> }
<ide>
<ide> /**
<ide> class ObjectMiddleware extends SerializerMiddleware {
<ide> };
<ide> let currentPosTypeLookup = 0;
<ide> let objectTypeLookup = [];
<del> const result = [];
<del> const ctx = {
<add> let result = [];
<add> let ctx = {
<ide> read() {
<ide> return decodeValue();
<ide> },
<ide> class ObjectMiddleware extends SerializerMiddleware {
<ide> }
<ide> };
<ide>
<del> while (currentDataPos < data.length) {
<del> result.push(decodeValue());
<add> try {
<add> while (currentDataPos < data.length) {
<add> result.push(decodeValue());
<add> }
<add> return result;
<add> } finally {
<add> // Get rid of these references to avoid leaking memory
<add> // This happens because the optimized code v8 generates
<add> // is optimized for our "ctx.read" method so it will reference
<add> // it from e. g. Dependency.prototype.deserialize -(IC)-> ctx.read
<add> result = referenceable = data = objectTypeLookup = ctx = undefined;
<ide> }
<del>
<del> // Help the GC, as functions above might be cached in inline caches
<del> referenceable = undefined;
<del> objectTypeLookup = undefined;
<del> data = undefined;
<del>
<del> return result;
<ide> }
<ide> }
<ide> | 1 |
Javascript | Javascript | remove deprecated calls from statusbarios | 4de616b4c1a9d3556632a93504828f0539fa4fa5 | <ide><path>Examples/UIExplorer/StatusBarIOSExample.js
<del>/**
<del> * The examples provided by Facebook are for non-commercial testing and
<del> * evaluation purposes only.
<del> *
<del> * Facebook reserves all rights not expressly granted.
<del> *
<del> * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
<del> * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
<del> * FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL
<del> * FACEBOOK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
<del> * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
<del> * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
<del> *
<del> * @flow
<del> */
<del>'use strict';
<del>
<del>var React = require('react');
<del>var ReactNative = require('react-native');
<del>var {
<del> StyleSheet,
<del> View,
<del> Text,
<del> TouchableHighlight,
<del> StatusBarIOS,
<del>} = ReactNative;
<del>
<del>exports.framework = 'React';
<del>exports.title = 'StatusBarIOS';
<del>exports.description = 'Module for controlling iOS status bar';
<del>exports.examples = [{
<del> title: 'Status Bar Style',
<del> render() {
<del> return (
<del> <View>
<del> {['default', 'light-content'].map((style) =>
<del> <TouchableHighlight key={style} style={styles.wrapper}
<del> onPress={() => StatusBarIOS.setStyle(style)}>
<del> <View style={styles.button}>
<del> <Text>setStyle('{style}')</Text>
<del> </View>
<del> </TouchableHighlight>
<del> )}
<del> </View>
<del> );
<del> },
<del>}, {
<del> title: 'Status Bar Style Animated',
<del> render() {
<del> return (
<del> <View>
<del> {['default', 'light-content'].map((style) =>
<del> <TouchableHighlight key={style} style={styles.wrapper}
<del> onPress={() => StatusBarIOS.setStyle(style, true)}>
<del> <View style={styles.button}>
<del> <Text>setStyle('{style}', true)</Text>
<del> </View>
<del> </TouchableHighlight>
<del> )}
<del> </View>
<del> );
<del> },
<del>}, {
<del> title: 'Status Bar Hidden',
<del> render() {
<del> return (
<del> <View>
<del> {['none', 'fade', 'slide'].map((animation) =>
<del> <View key={animation}>
<del> <TouchableHighlight style={styles.wrapper}
<del> onPress={() => StatusBarIOS.setHidden(true, animation)}>
<del> <View style={styles.button}>
<del> <Text>setHidden(true, '{animation}')</Text>
<del> </View>
<del> </TouchableHighlight>
<del> <TouchableHighlight style={styles.wrapper}
<del> onPress={() => StatusBarIOS.setHidden(false, animation)}>
<del> <View style={styles.button}>
<del> <Text>setHidden(false, '{animation}')</Text>
<del> </View>
<del> </TouchableHighlight>
<del> </View>
<del> )}
<del> </View>
<del> );
<del> },
<del>}, {
<del> title: 'Status Bar Network Activity Indicator',
<del> render() {
<del> return (
<del> <View>
<del> <TouchableHighlight style={styles.wrapper}
<del> onPress={() => StatusBarIOS.setNetworkActivityIndicatorVisible(true)}>
<del> <View style={styles.button}>
<del> <Text>setNetworkActivityIndicatorVisible(true)</Text>
<del> </View>
<del> </TouchableHighlight>
<del> <TouchableHighlight style={styles.wrapper}
<del> onPress={() => StatusBarIOS.setNetworkActivityIndicatorVisible(false)}>
<del> <View style={styles.button}>
<del> <Text>setNetworkActivityIndicatorVisible(false)</Text>
<del> </View>
<del> </TouchableHighlight>
<del> </View>
<del> );
<del> },
<del>}];
<del>
<del>var styles = StyleSheet.create({
<del> wrapper: {
<del> borderRadius: 5,
<del> marginBottom: 5,
<del> },
<del> button: {
<del> backgroundColor: '#eeeeee',
<del> padding: 10,
<del> },
<del>});
<ide><path>Examples/UIExplorer/UIExplorerList.ios.js
<ide> const APIExamples: Array<UIExplorerExample> = [
<ide> key: 'SnapshotExample',
<ide> module: require('./SnapshotExample'),
<ide> },
<del> {
<del> key: 'StatusBarIOSExample',
<del> module: require('./StatusBarIOSExample'),
<del> },
<ide> {
<ide> key: 'TimerExample',
<ide> module: require('./TimerExample'),
<ide><path>Libraries/Components/StatusBar/StatusBarIOS.ios.js
<ide> 'use strict';
<ide>
<ide> const NativeEventEmitter = require('NativeEventEmitter');
<del>const StatusBar = require('StatusBar');
<del>const StatusBarManager = require('NativeModules').StatusBarManager;
<del>
<del>import type {StatusBarStyle, StatusBarAnimation} from 'StatusBar';
<add>const { StatusBarManager } = require('NativeModules');
<ide>
<ide> /**
<del> * Deprecated. Use `StatusBar` instead.
<add> * Use `StatusBar` for mutating the status bar.
<ide> */
<del>class StatusBarIOS extends NativeEventEmitter {
<del>
<del> setStyle(style: StatusBarStyle, animated?: boolean) {
<del> console.warn('`StatusBarIOS.setStyle` is deprecated. Use `StatusBar.setBarStyle` instead.');
<del> StatusBar.setBarStyle(style, animated);
<del> }
<del>
<del> setHidden(hidden: boolean, animation?: StatusBarAnimation) {
<del> console.warn('`StatusBarIOS.setHidden` is deprecated. Use `StatusBar.setHidden` instead.');
<del> StatusBar.setHidden(hidden, animation);
<del> }
<del>
<del> setNetworkActivityIndicatorVisible(visible: boolean) {
<del> console.warn(
<del> '`StatusBarIOS.setNetworkActivityIndicatorVisible` is deprecated. ' +
<del> 'Use `StatusBar.setNetworkActivityIndicatorVisible` instead.'
<del> );
<del> StatusBar.setNetworkActivityIndicatorVisible(visible);
<del> }
<del>}
<add>class StatusBarIOS extends NativeEventEmitter {}
<ide>
<ide> module.exports = new StatusBarIOS(StatusBarManager); | 3 |
PHP | PHP | remove unnecessary assignment | 78d3974eaa6341b0c8e6a1fbda3168a09739353c | <ide><path>tests/TestCase/Controller/ControllerTest.php
<ide> public function testInvokeActionException()
<ide> $response = $this->getMockBuilder(Response::class)->getMock();
<ide>
<ide> $Controller = new TestController($url, $response);
<del> $result = $Controller->invokeAction();
<add> $Controller->invokeAction();
<ide> }
<ide>
<ide> /** | 1 |
Java | Java | add missing coverage, fix unused/inconsistent ops | b3ad0752de398f4536bb88a7b1c77b0b9fbecb87 | <ide><path>src/main/java/io/reactivex/rxjava3/core/Completable.java
<ide> private static Completable merge0(@NonNull Publisher<@NonNull ? extends Completa
<ide> @SafeVarargs
<ide> public static Completable mergeArrayDelayError(@NonNull CompletableSource... sources) {
<ide> Objects.requireNonNull(sources, "sources is null");
<del> return RxJavaPlugins.onAssembly(new CompletableMergeDelayErrorArray(sources));
<add> return RxJavaPlugins.onAssembly(new CompletableMergeArrayDelayError(sources));
<ide> }
<ide>
<ide> /**
<ide><path>src/main/java/io/reactivex/rxjava3/internal/functions/Functions.java
<ide> public static <T> Predicate<T> equalsWith(T value) {
<ide> return new EqualsPredicate<>(value);
<ide> }
<ide>
<del> enum HashSetCallable implements Supplier<Set<Object>>, Callable<Set<Object>> {
<add> enum HashSetSupplier implements Supplier<Set<Object>> {
<ide> INSTANCE;
<del> @Override
<del> public Set<Object> call() {
<del> return new HashSet<>();
<del> }
<del>
<ide> @Override
<ide> public Set<Object> get() {
<ide> return new HashSet<>();
<ide> public Set<Object> get() {
<ide>
<ide> @SuppressWarnings({ "rawtypes", "unchecked" })
<ide> public static <T> Supplier<Set<T>> createHashSet() {
<del> return (Supplier)HashSetCallable.INSTANCE;
<add> return (Supplier)HashSetSupplier.INSTANCE;
<ide> }
<ide>
<ide> static final class NotificationOnNext<T> implements Consumer<T> {
<ide> public boolean test(Object o) {
<ide> }
<ide> }
<ide>
<del> static final class NullProvider implements Callable<Object>, Supplier<Object> {
<del> @Override
<del> public Object call() {
<del> return null;
<del> }
<del>
<add> static final class NullProvider implements Supplier<Object> {
<ide> @Override
<ide> public Object get() {
<ide> return null;
<ide><path>src/main/java/io/reactivex/rxjava3/internal/observers/FutureObserver.java
<ide> public void onNext(T t) {
<ide> @Override
<ide> public void onError(Throwable t) {
<ide> if (error == null) {
<del> error = t;
<del>
<del> for (;;) {
<del> Disposable a = upstream.get();
<del> if (a == this || a == DisposableHelper.DISPOSED) {
<del> RxJavaPlugins.onError(t);
<del> return;
<del> }
<del> if (upstream.compareAndSet(a, this)) {
<del> countDown();
<del> return;
<del> }
<add> Disposable a = upstream.get();
<add> if (a != this && a != DisposableHelper.DISPOSED
<add> && upstream.compareAndSet(a, this)) {
<add> error = t;
<add> countDown();
<add> return;
<ide> }
<del> } else {
<del> RxJavaPlugins.onError(t);
<ide> }
<add> RxJavaPlugins.onError(t);
<ide> }
<ide>
<ide> @Override
<ide> public void onComplete() {
<ide> onError(new NoSuchElementException("The source is empty"));
<ide> return;
<ide> }
<del> for (;;) {
<del> Disposable a = upstream.get();
<del> if (a == this || a == DisposableHelper.DISPOSED) {
<del> return;
<del> }
<del> if (upstream.compareAndSet(a, this)) {
<del> countDown();
<del> return;
<del> }
<add> Disposable a = upstream.get();
<add> if (a == this || a == DisposableHelper.DISPOSED) {
<add> return;
<add> }
<add> if (upstream.compareAndSet(a, this)) {
<add> countDown();
<ide> }
<ide> }
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/observers/InnerQueuedObserver.java
<ide> public void setDone() {
<ide> public SimpleQueue<T> queue() {
<ide> return queue;
<ide> }
<del>
<del> public int fusionMode() {
<del> return fusionMode;
<del> }
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/observers/QueueDrainObserver.java
<ide> public final boolean enter() {
<ide> return wip.getAndIncrement() == 0;
<ide> }
<ide>
<del> public final boolean fastEnter() {
<del> return wip.get() == 0 && wip.compareAndSet(0, 1);
<del> }
<del>
<ide> protected final void fastPathEmit(U value, boolean delayError, Disposable dispose) {
<ide> final Observer<? super V> observer = downstream;
<ide> final SimplePlainQueue<U> q = queue;
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/completable/CompletableConcat.java
<ide> void drain() {
<ide> boolean empty = cs == null;
<ide>
<ide> if (d && empty) {
<del> if (once.compareAndSet(false, true)) {
<del> downstream.onComplete();
<del> }
<add> // errors never set done or call drain.
<add> downstream.onComplete();
<ide> return;
<ide> }
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/completable/CompletableMergeArray.java
<ide> public void onError(Throwable e) {
<ide> @Override
<ide> public void onComplete() {
<ide> if (decrementAndGet() == 0) {
<del> if (once.compareAndSet(false, true)) {
<del> downstream.onComplete();
<del> }
<add> // errors don't decrement this
<add> downstream.onComplete();
<ide> }
<ide> }
<ide>
<add><path>src/main/java/io/reactivex/rxjava3/internal/operators/completable/CompletableMergeArrayDelayError.java
<del><path>src/main/java/io/reactivex/rxjava3/internal/operators/completable/CompletableMergeDelayErrorArray.java
<ide> import io.reactivex.rxjava3.disposables.*;
<ide> import io.reactivex.rxjava3.internal.util.AtomicThrowable;
<ide>
<del>public final class CompletableMergeDelayErrorArray extends Completable {
<add>public final class CompletableMergeArrayDelayError extends Completable {
<ide>
<ide> final CompletableSource[] sources;
<ide>
<del> public CompletableMergeDelayErrorArray(CompletableSource[] sources) {
<add> public CompletableMergeArrayDelayError(CompletableSource[] sources) {
<ide> this.sources = sources;
<ide> }
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/completable/CompletableMergeDelayErrorIterable.java
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.disposables.CompositeDisposable;
<ide> import io.reactivex.rxjava3.exceptions.Exceptions;
<del>import io.reactivex.rxjava3.internal.operators.completable.CompletableMergeDelayErrorArray.*;
<add>import io.reactivex.rxjava3.internal.operators.completable.CompletableMergeArrayDelayError.*;
<ide> import io.reactivex.rxjava3.internal.util.AtomicThrowable;
<ide>
<ide> public final class CompletableMergeDelayErrorIterable extends Completable {
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/completable/CompletableMergeIterable.java
<ide> public void onError(Throwable e) {
<ide> @Override
<ide> public void onComplete() {
<ide> if (wip.decrementAndGet() == 0) {
<del> if (compareAndSet(false, true)) {
<del> downstream.onComplete();
<del> }
<add> // errors don't decrement wip
<add> downstream.onComplete();
<ide> }
<ide> }
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/BlockingFlowableNext.java
<ide> private boolean moveToNext() {
<ide> if (nextNotification.isOnComplete()) {
<ide> return false;
<ide> }
<del> if (nextNotification.isOnError()) {
<del> error = nextNotification.getError();
<del> throw ExceptionHelper.wrapOrThrow(error);
<del> }
<del> throw new IllegalStateException("Should not reach here");
<add> error = nextNotification.getError();
<add> throw ExceptionHelper.wrapOrThrow(error);
<ide> } catch (InterruptedException e) {
<ide> subscriber.dispose();
<ide> error = e;
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableBuffer.java
<ide> public void onError(Throwable t) {
<ide> RxJavaPlugins.onError(t);
<ide> return;
<ide> }
<add> buffer = null;
<ide> done = true;
<ide> downstream.onError(t);
<ide> }
<ide> public void onComplete() {
<ide> done = true;
<ide>
<ide> C b = buffer;
<add> buffer = null;
<ide>
<del> if (b != null && !b.isEmpty()) {
<add> if (b != null) {
<ide> downstream.onNext(b);
<ide> }
<ide> downstream.onComplete();
<ide> public void onNext(T t) {
<ide>
<ide> C b = bs.peek();
<ide>
<del> if (b != null && b.size() + 1 == size) {
<add> if (b.size() + 1 == size) {
<ide> bs.poll();
<ide>
<ide> b.add(t);
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableCombineLatest.java
<ide>
<ide> package io.reactivex.rxjava3.internal.operators.flowable;
<ide>
<del>import java.util.Iterator;
<ide> import java.util.Objects;
<ide> import java.util.concurrent.atomic.*;
<ide>
<ide> public FlowableCombineLatest(@NonNull Iterable<? extends Publisher<? extends T>>
<ide> @SuppressWarnings("unchecked")
<ide> @Override
<ide> public void subscribeActual(Subscriber<? super R> s) {
<del> Publisher<? extends T>[] a = array;
<del> int n;
<del> if (a == null) {
<del> n = 0;
<del> a = new Publisher[8];
<del>
<del> Iterator<? extends Publisher<? extends T>> it;
<add> Publisher<? extends T>[] sources = array;
<add> int count;
<add> if (sources == null) {
<add> count = 0;
<add> sources = new Publisher[8];
<ide>
<ide> try {
<del> it = Objects.requireNonNull(iterable.iterator(), "The iterator returned is null");
<del> } catch (Throwable e) {
<del> Exceptions.throwIfFatal(e);
<del> EmptySubscription.error(e, s);
<del> return;
<del> }
<del>
<del> for (;;) {
<del>
<del> boolean b;
<del>
<del> try {
<del> b = it.hasNext();
<del> } catch (Throwable e) {
<del> Exceptions.throwIfFatal(e);
<del> EmptySubscription.error(e, s);
<del> return;
<del> }
<del>
<del> if (!b) {
<del> break;
<del> }
<del>
<del> Publisher<? extends T> p;
<del>
<del> try {
<del> p = Objects.requireNonNull(it.next(), "The publisher returned by the iterator is null");
<del> } catch (Throwable e) {
<del> Exceptions.throwIfFatal(e);
<del> EmptySubscription.error(e, s);
<del> return;
<del> }
<del>
<del> if (n == a.length) {
<del> Publisher<? extends T>[] c = new Publisher[n + (n >> 2)];
<del> System.arraycopy(a, 0, c, 0, n);
<del> a = c;
<add> for (Publisher<? extends T> p : iterable) {
<add> if (count == sources.length) {
<add> Publisher<? extends T>[] b = new Publisher[count + (count >> 2)];
<add> System.arraycopy(sources, 0, b, 0, count);
<add> sources = b;
<add> }
<add> sources[count++] = Objects.requireNonNull(p, "The Iterator returned a null Publisher");
<ide> }
<del> a[n++] = p;
<add> } catch (Throwable ex) {
<add> Exceptions.throwIfFatal(ex);
<add> EmptySubscription.error(ex, s);
<add> return;
<ide> }
<ide>
<ide> } else {
<del> n = a.length;
<add> count = sources.length;
<ide> }
<ide>
<del> if (n == 0) {
<add> if (count == 0) {
<ide> EmptySubscription.complete(s);
<ide> return;
<ide> }
<del> if (n == 1) {
<del> a[0].subscribe(new MapSubscriber<>(s, new SingletonArrayFunc()));
<add> if (count == 1) {
<add> sources[0].subscribe(new MapSubscriber<>(s, new SingletonArrayFunc()));
<ide> return;
<ide> }
<ide>
<ide> CombineLatestCoordinator<T, R> coordinator =
<del> new CombineLatestCoordinator<>(s, combiner, n, bufferSize, delayErrors);
<add> new CombineLatestCoordinator<>(s, combiner, count, bufferSize, delayErrors);
<ide>
<ide> s.onSubscribe(coordinator);
<ide>
<del> coordinator.subscribe(a, n);
<add> coordinator.subscribe(sources, count);
<ide> }
<ide>
<ide> static final class CombineLatestCoordinator<T, R>
<ide> public void subscribeActual(Subscriber<? super R> s) {
<ide>
<ide> volatile boolean done;
<ide>
<del> final AtomicReference<Throwable> error;
<add> final AtomicThrowable error;
<ide>
<ide> CombineLatestCoordinator(Subscriber<? super R> actual,
<ide> Function<? super Object[], ? extends R> combiner, int n,
<ide> public void subscribeActual(Subscriber<? super R> s) {
<ide> this.latest = new Object[n];
<ide> this.queue = new SpscLinkedArrayQueue<>(bufferSize);
<ide> this.requested = new AtomicLong();
<del> this.error = new AtomicReference<>();
<add> this.error = new AtomicThrowable();
<ide> this.delayErrors = delayErrors;
<ide> }
<ide>
<ide> public void request(long n) {
<ide> public void cancel() {
<ide> cancelled = true;
<ide> cancelAll();
<add> drain();
<ide> }
<ide>
<ide> void subscribe(Publisher<? extends T>[] sources, int n) {
<ide> boolean checkTerminated(boolean d, boolean empty, Subscriber<?> a, SpscLinkedArr
<ide> if (cancelled) {
<ide> cancelAll();
<ide> q.clear();
<add> error.tryTerminateAndReport();
<ide> return true;
<ide> }
<ide>
<ide> if (d) {
<ide> if (delayErrors) {
<ide> if (empty) {
<ide> cancelAll();
<del> Throwable e = ExceptionHelper.terminate(error);
<del>
<del> if (e != null && e != ExceptionHelper.TERMINATED) {
<del> a.onError(e);
<del> } else {
<del> a.onComplete();
<del> }
<add> error.tryTerminateConsumer(a);
<ide> return true;
<ide> }
<ide> } else {
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableConcatMap.java
<ide> void subscribeActual() {
<ide>
<ide> @Override
<ide> public void onError(Throwable t) {
<del> if (errors.tryAddThrowableOrReport(t)) {
<del> inner.cancel();
<del>
<del> if (getAndIncrement() == 0) {
<del> errors.tryTerminateConsumer(downstream);
<del> }
<del> }
<add> inner.cancel();
<add> HalfSerializer.onError(downstream, t, this, errors);
<ide> }
<ide>
<ide> @Override
<ide> public void innerNext(R value) {
<del> if (get() == 0 && compareAndSet(0, 1)) {
<del> downstream.onNext(value);
<del> if (compareAndSet(1, 0)) {
<del> return;
<del> }
<del> errors.tryTerminateConsumer(downstream);
<del> }
<add> HalfSerializer.onNext(downstream, value, this, errors);
<ide> }
<ide>
<ide> @Override
<ide> public void innerError(Throwable e) {
<del> if (errors.tryAddThrowableOrReport(e)) {
<del> upstream.cancel();
<del>
<del> if (getAndIncrement() == 0) {
<del> errors.tryTerminateConsumer(downstream);
<del> }
<del> }
<add> upstream.cancel();
<add> HalfSerializer.onError(downstream, e, this, errors);
<ide> }
<ide>
<ide> @Override
<ide> void drain() {
<ide> }
<ide>
<ide> if (inner.isUnbounded()) {
<del> if (get() == 0 && compareAndSet(0, 1)) {
<del> downstream.onNext(vr);
<del> if (!compareAndSet(1, 0)) {
<del> errors.tryTerminateConsumer(downstream);
<del> return;
<del> }
<add> if (!HalfSerializer.onNext(downstream, vr, this, errors)) {
<add> return;
<ide> }
<ide> continue;
<ide> } else {
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableConcatMapEager.java
<ide> public void drain() {
<ide>
<ide> e++;
<ide>
<del> inner.requestOne();
<add> inner.request(1L);
<ide> }
<ide>
<ide> if (e == r) {
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableConcatMapScheduler.java
<ide> public void onError(Throwable t) {
<ide> }
<ide> }
<ide>
<add> boolean tryEnter() {
<add> return get() == 0 && compareAndSet(0, 1);
<add> }
<add>
<ide> @Override
<ide> public void innerNext(R value) {
<del> if (get() == 0 && compareAndSet(0, 1)) {
<add> if (tryEnter()) {
<ide> downstream.onNext(value);
<ide> if (compareAndSet(1, 0)) {
<ide> return;
<ide> public void run() {
<ide> return;
<ide> }
<ide>
<del> if (vr == null) {
<add> if (vr == null || cancelled) {
<ide> continue;
<ide> }
<ide>
<ide> if (inner.isUnbounded()) {
<del> if (get() == 0 && compareAndSet(0, 1)) {
<add> if (tryEnter()) {
<ide> downstream.onNext(vr);
<ide> if (!compareAndSet(1, 0)) {
<ide> errors.tryTerminateConsumer(downstream);
<ide> public void run() {
<ide> vr = null;
<ide> }
<ide>
<del> if (vr == null) {
<add> if (vr == null || cancelled) {
<ide> continue;
<ide> }
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFlatMap.java
<ide> public void onNext(T t) {
<ide> if (u != null) {
<ide> tryEmitScalar(u);
<ide> } else {
<del> if (maxConcurrency != Integer.MAX_VALUE && !cancelled
<del> && ++scalarEmitted == scalarLimit) {
<add> if (maxConcurrency != Integer.MAX_VALUE
<add> && !cancelled && ++scalarEmitted == scalarLimit) {
<ide> scalarEmitted = 0;
<ide> upstream.request(scalarLimit);
<ide> }
<ide> }
<ide> } else {
<del> InnerSubscriber<T, U> inner = new InnerSubscriber<>(this, uniqueId++);
<add> InnerSubscriber<T, U> inner = new InnerSubscriber<>(this, bufferSize, uniqueId++);
<ide> if (addInner(inner)) {
<ide> p.subscribe(inner);
<ide> }
<ide> void tryEmitScalar(U value) {
<ide> if (r != Long.MAX_VALUE) {
<ide> requested.decrementAndGet();
<ide> }
<del> if (maxConcurrency != Integer.MAX_VALUE && !cancelled
<del> && ++scalarEmitted == scalarLimit) {
<add> if (maxConcurrency != Integer.MAX_VALUE
<add> && !cancelled && ++scalarEmitted == scalarLimit) {
<ide> scalarEmitted = 0;
<ide> upstream.request(scalarLimit);
<ide> }
<ide> void tryEmitScalar(U value) {
<ide> q = getMainQueue();
<ide> }
<ide> if (!q.offer(value)) {
<del> onError(new IllegalStateException("Scalar queue full?!"));
<del> return;
<add> onError(new MissingBackpressureException("Scalar queue full?!"));
<ide> }
<ide> }
<ide> if (decrementAndGet() == 0) {
<ide> void tryEmitScalar(U value) {
<ide> } else {
<ide> SimpleQueue<U> q = getMainQueue();
<ide> if (!q.offer(value)) {
<del> onError(new IllegalStateException("Scalar queue full?!"));
<add> onError(new MissingBackpressureException("Scalar queue full?!"));
<ide> return;
<ide> }
<ide> if (getAndIncrement() != 0) {
<ide> void tryEmitScalar(U value) {
<ide> drainLoop();
<ide> }
<ide>
<del> SimpleQueue<U> getInnerQueue(InnerSubscriber<T, U> inner) {
<del> SimpleQueue<U> q = inner.queue;
<del> if (q == null) {
<del> q = new SpscArrayQueue<>(bufferSize);
<del> inner.queue = q;
<del> }
<del> return q;
<del> }
<del>
<ide> void tryEmit(U value, InnerSubscriber<T, U> inner) {
<ide> if (get() == 0 && compareAndSet(0, 1)) {
<ide> long r = requested.get();
<ide> void tryEmit(U value, InnerSubscriber<T, U> inner) {
<ide> inner.requestMore(1);
<ide> } else {
<ide> if (q == null) {
<del> q = getInnerQueue(inner);
<add> q = new SpscArrayQueue<>(bufferSize);
<add> inner.queue = q;
<ide> }
<ide> if (!q.offer(value)) {
<ide> onError(new MissingBackpressureException("Inner queue full?!"));
<del> return;
<ide> }
<ide> }
<ide> if (decrementAndGet() == 0) {
<ide> void drainLoop() {
<ide> long replenishMain = 0;
<ide>
<ide> if (svq != null) {
<del> for (;;) {
<del> long scalarEmission = 0;
<del> U o = null;
<del> while (r != 0L) {
<del> o = svq.poll();
<add> long scalarEmission = 0;
<add> U o = null;
<add> while (r != 0L) {
<add> o = svq.poll();
<ide>
<del> if (checkTerminate()) {
<del> return;
<del> }
<del> if (o == null) {
<del> break;
<del> }
<del>
<del> child.onNext(o);
<del>
<del> replenishMain++;
<del> scalarEmission++;
<del> r--;
<del> }
<del> if (scalarEmission != 0L) {
<del> if (unbounded) {
<del> r = Long.MAX_VALUE;
<del> } else {
<del> r = requested.addAndGet(-scalarEmission);
<del> }
<add> if (checkTerminate()) {
<add> return;
<ide> }
<del> if (r == 0L || o == null) {
<add> if (o == null) {
<ide> break;
<ide> }
<add>
<add> child.onNext(o);
<add>
<add> replenishMain++;
<add> scalarEmission++;
<add> r--;
<add> }
<add> if (scalarEmission != 0L) {
<add> if (unbounded) {
<add> r = Long.MAX_VALUE;
<add> } else {
<add> r = requested.addAndGet(-scalarEmission);
<add> }
<ide> }
<ide> }
<ide>
<ide> void drainLoop() {
<ide>
<ide> U o = null;
<ide> for (;;) {
<del> if (checkTerminate()) {
<del> return;
<del> }
<ide> SimpleQueue<U> q = is.queue;
<ide> if (q == null) {
<ide> break;
<ide> }
<ide> long produced = 0;
<ide> while (r != 0L) {
<add> if (checkTerminate()) {
<add> return;
<add> }
<ide>
<ide> try {
<ide> o = q.poll();
<ide> void drainLoop() {
<ide>
<ide> child.onNext(o);
<ide>
<del> if (checkTerminate()) {
<del> return;
<del> }
<del>
<ide> r--;
<ide> produced++;
<ide> }
<ide> void clearScalarQueue() {
<ide> }
<ide>
<ide> void disposeAll() {
<del> InnerSubscriber<?, ?>[] a = subscribers.get();
<add> InnerSubscriber<?, ?>[] a = subscribers.getAndSet(CANCELLED);
<ide> if (a != CANCELLED) {
<del> a = subscribers.getAndSet(CANCELLED);
<del> if (a != CANCELLED) {
<del> for (InnerSubscriber<?, ?> inner : a) {
<del> inner.dispose();
<del> }
<del> errors.tryTerminateAndReport();
<add> for (InnerSubscriber<?, ?> inner : a) {
<add> inner.dispose();
<ide> }
<add> errors.tryTerminateAndReport();
<ide> }
<ide> }
<ide>
<ide> void innerError(InnerSubscriber<T, U> inner, Throwable t) {
<ide> long produced;
<ide> int fusionMode;
<ide>
<del> InnerSubscriber(MergeSubscriber<T, U> parent, long id) {
<add> InnerSubscriber(MergeSubscriber<T, U> parent, int bufferSize, long id) {
<ide> this.id = id;
<ide> this.parent = parent;
<del> this.bufferSize = parent.bufferSize;
<add> this.bufferSize = bufferSize;
<ide> this.limit = bufferSize >> 2;
<ide> }
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFlatMapCompletable.java
<ide> public void onError(Throwable e) {
<ide> cancelled = true;
<ide> upstream.cancel();
<ide> set.dispose();
<del> if (getAndSet(0) > 0) {
<del> errors.tryTerminateConsumer(downstream);
<del> }
<add> errors.tryTerminateConsumer(downstream);
<ide> }
<ide> }
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFlatMapCompletableCompletable.java
<ide> public void onError(Throwable e) {
<ide> disposed = true;
<ide> upstream.cancel();
<ide> set.dispose();
<del> if (getAndSet(0) > 0) {
<del> errors.tryTerminateConsumer(downstream);
<del> }
<add> errors.tryTerminateConsumer(downstream);
<ide> }
<ide> }
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFlatMapMaybe.java
<ide> void innerSuccess(InnerObserver inner, R value) {
<ide>
<ide> SpscLinkedArrayQueue<R> q = queue.get();
<ide>
<del> if (d && (q == null || q.isEmpty())) {
<add> if (checkTerminate(d, q)) {
<ide> errors.tryTerminateConsumer(downstream);
<ide> return;
<ide> }
<ide> void innerSuccess(InnerObserver inner, R value) {
<ide> }
<ide>
<ide> SpscLinkedArrayQueue<R> getOrCreateQueue() {
<del> for (;;) {
<del> SpscLinkedArrayQueue<R> current = queue.get();
<del> if (current != null) {
<del> return current;
<del> }
<del> current = new SpscLinkedArrayQueue<>(Flowable.bufferSize());
<del> if (queue.compareAndSet(null, current)) {
<del> return current;
<del> }
<add> SpscLinkedArrayQueue<R> current = queue.get();
<add> if (current != null) {
<add> return current;
<ide> }
<add> current = new SpscLinkedArrayQueue<>(Flowable.bufferSize());
<add> if (queue.compareAndSet(null, current)) {
<add> return current;
<add> }
<add> return queue.get();
<ide> }
<ide>
<ide> void innerError(InnerObserver inner, Throwable e) {
<ide> void innerComplete(InnerObserver inner) {
<ide> boolean d = active.decrementAndGet() == 0;
<ide> SpscLinkedArrayQueue<R> q = queue.get();
<ide>
<del> if (d && (q == null || q.isEmpty())) {
<add> if (checkTerminate(d, q)) {
<ide> errors.tryTerminateConsumer(downstream);
<ide> return;
<ide> }
<ide> void innerComplete(InnerObserver inner) {
<ide> }
<ide> }
<ide>
<add> static boolean checkTerminate(boolean d, SpscLinkedArrayQueue<?> q) {
<add> return d && (q == null || q.isEmpty());
<add> }
<add>
<ide> void drain() {
<ide> if (getAndIncrement() == 0) {
<ide> drainLoop();
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFlatMapSingle.java
<ide> void innerSuccess(InnerObserver inner, R value) {
<ide> }
<ide>
<ide> SpscLinkedArrayQueue<R> getOrCreateQueue() {
<del> for (;;) {
<del> SpscLinkedArrayQueue<R> current = queue.get();
<del> if (current != null) {
<del> return current;
<del> }
<del> current = new SpscLinkedArrayQueue<>(Flowable.bufferSize());
<del> if (queue.compareAndSet(null, current)) {
<del> return current;
<del> }
<add> SpscLinkedArrayQueue<R> current = queue.get();
<add> if (current != null) {
<add> return current;
<add> }
<add> current = new SpscLinkedArrayQueue<>(Flowable.bufferSize());
<add> if (queue.compareAndSet(null, current)) {
<add> return current;
<ide> }
<add> return queue.get();
<ide> }
<ide>
<ide> void innerError(InnerObserver inner, Throwable e) {
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFromIterable.java
<ide> public static <T> void subscribe(Subscriber<? super T> s, Iterator<? extends T>
<ide> abstract static class BaseRangeSubscription<T> extends BasicQueueSubscription<T> {
<ide> private static final long serialVersionUID = -2252972430506210021L;
<ide>
<del> Iterator<? extends T> it;
<add> Iterator<? extends T> iterator;
<ide>
<ide> volatile boolean cancelled;
<ide>
<ide> boolean once;
<ide>
<ide> BaseRangeSubscription(Iterator<? extends T> it) {
<del> this.it = it;
<add> this.iterator = it;
<ide> }
<ide>
<ide> @Override
<ide> public final int requestFusion(int mode) {
<ide> @Nullable
<ide> @Override
<ide> public final T poll() {
<del> if (it == null) {
<add> if (iterator == null) {
<ide> return null;
<ide> }
<ide> if (!once) {
<ide> once = true;
<ide> } else {
<del> if (!it.hasNext()) {
<add> if (!iterator.hasNext()) {
<ide> return null;
<ide> }
<ide> }
<del> return Objects.requireNonNull(it.next(), "Iterator.next() returned a null value");
<add> return Objects.requireNonNull(iterator.next(), "Iterator.next() returned a null value");
<ide> }
<ide>
<ide> @Override
<ide> public final boolean isEmpty() {
<del> return it == null || !it.hasNext();
<add> Iterator<? extends T> it = this.iterator;
<add> if (it != null) {
<add> if (!once || it.hasNext()) {
<add> return false;
<add> }
<add> clear();
<add> }
<add> return true;
<ide> }
<ide>
<ide> @Override
<ide> public final void clear() {
<del> it = null;
<add> iterator = null;
<ide> }
<ide>
<ide> @Override
<ide> public final void cancel() {
<ide>
<ide> @Override
<ide> void fastPath() {
<del> Iterator<? extends T> it = this.it;
<add> Iterator<? extends T> it = this.iterator;
<ide> Subscriber<? super T> a = downstream;
<ide> for (;;) {
<ide> if (cancelled) {
<ide> void fastPath() {
<ide> @Override
<ide> void slowPath(long r) {
<ide> long e = 0L;
<del> Iterator<? extends T> it = this.it;
<add> Iterator<? extends T> it = this.iterator;
<ide> Subscriber<? super T> a = downstream;
<ide>
<ide> for (;;) {
<ide> void slowPath(long r) {
<ide>
<ide> @Override
<ide> void fastPath() {
<del> Iterator<? extends T> it = this.it;
<add> Iterator<? extends T> it = this.iterator;
<ide> ConditionalSubscriber<? super T> a = downstream;
<ide> for (;;) {
<ide> if (cancelled) {
<ide> void fastPath() {
<ide> @Override
<ide> void slowPath(long r) {
<ide> long e = 0L;
<del> Iterator<? extends T> it = this.it;
<add> Iterator<? extends T> it = this.iterator;
<ide> ConditionalSubscriber<? super T> a = downstream;
<ide>
<ide> for (;;) {
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableGroupJoin.java
<ide> else if (mode == LEFT_CLOSE) {
<ide> up.onComplete();
<ide> }
<ide> }
<del> else if (mode == RIGHT_CLOSE) {
<add> else {
<ide> LeftRightEndSubscriber end = (LeftRightEndSubscriber)val;
<ide>
<ide> rights.remove(end.index);
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableJoin.java
<ide> else if (mode == LEFT_CLOSE) {
<ide> lefts.remove(end.index);
<ide> disposables.remove(end);
<ide> }
<del> else if (mode == RIGHT_CLOSE) {
<add> else {
<ide> LeftRightEndSubscriber end = (LeftRightEndSubscriber)val;
<ide>
<ide> rights.remove(end.index);
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableObserveOn.java
<ide> void runSync() {
<ide> return;
<ide> }
<ide>
<del> int w = get();
<del> if (missed == w) {
<del> produced = e;
<del> missed = addAndGet(-missed);
<del> if (missed == 0) {
<del> break;
<del> }
<del> } else {
<del> missed = w;
<add> produced = e;
<add> missed = addAndGet(-missed);
<add> if (missed == 0) {
<add> break;
<ide> }
<ide> }
<ide> }
<ide> void runSync() {
<ide> return;
<ide> }
<ide>
<del> int w = get();
<del> if (missed == w) {
<del> produced = e;
<del> missed = addAndGet(-missed);
<del> if (missed == 0) {
<del> break;
<del> }
<del> } else {
<del> missed = w;
<add> produced = e;
<add> missed = addAndGet(-missed);
<add> if (missed == 0) {
<add> break;
<ide> }
<ide> }
<ide> }
<ide> void runAsync() {
<ide> return;
<ide> }
<ide>
<del> int w = get();
<del> if (missed == w) {
<del> produced = emitted;
<del> consumed = polled;
<del> missed = addAndGet(-missed);
<del> if (missed == 0) {
<del> break;
<del> }
<del> } else {
<del> missed = w;
<add> produced = emitted;
<add> consumed = polled;
<add> missed = addAndGet(-missed);
<add> if (missed == 0) {
<add> break;
<ide> }
<ide> }
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowablePublish.java
<ide> public Publisher<T> source() {
<ide> return source;
<ide> }
<ide>
<del> /**
<del> * The internal buffer size of this FlowablePublishAlt operator.
<del> * @return The internal buffer size of this FlowablePublishAlt operator.
<del> */
<del> public int publishBufferSize() {
<del> return bufferSize;
<del> }
<del>
<ide> @Override
<ide> public void connect(Consumer<? super Disposable> connection) {
<ide> PublishConnection<T> conn;
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableReplay.java
<ide> public void connect(Consumer<? super Disposable> connection) {
<ide>
<ide> final AtomicInteger management;
<ide>
<del> /** Contains the maximum element index the child Subscribers requested so far. Accessed while emitting is true. */
<del> long maxChildRequested;
<del> /** Counts the outstanding upstream requests until the producer arrives. */
<del> long maxUpstreamRequested;
<add> /** Tracks the amount already requested from the upstream. */
<add> long requestedFromUpstream;
<ide>
<ide> @SuppressWarnings("unchecked")
<ide> ReplaySubscriber(ReplayBuffer<T> buffer) {
<ide> public void dispose() {
<ide> */
<ide> @SuppressWarnings("unchecked")
<ide> boolean add(InnerSubscription<T> producer) {
<del> if (producer == null) {
<del> throw new NullPointerException();
<del> }
<ide> // the state can change so we do a CAS loop to achieve atomicity
<ide> for (;;) {
<ide> // get the current producer array
<ide> public void onComplete() {
<ide> * Coordinates the request amounts of various child Subscribers.
<ide> */
<ide> void manageRequests() {
<del> if (management.getAndIncrement() != 0) {
<add> AtomicInteger m = management;
<add> if (m.getAndIncrement() != 0) {
<ide> return;
<ide> }
<ide> int missed = 1;
<ide> void manageRequests() {
<ide> if (isDisposed()) {
<ide> return;
<ide> }
<add> Subscription p = get();
<ide>
<del> InnerSubscription<T>[] a = subscribers.get();
<del>
<del> long ri = maxChildRequested;
<del> long maxTotalRequests = ri;
<del>
<del> for (InnerSubscription<T> rp : a) {
<del> maxTotalRequests = Math.max(maxTotalRequests, rp.totalRequested.get());
<del> }
<add> // only request when there is an upstream Subscription available
<add> if (p != null) {
<add> // how many items were requested so far
<add> long alreadyRequested = requestedFromUpstream;
<add> long downstreamMaxRequest = alreadyRequested;
<ide>
<del> long ur = maxUpstreamRequested;
<del> Subscription p = get();
<add> // find out the maximum total requested of the current subscribers
<add> for (InnerSubscription<T> rp : subscribers.get()) {
<add> downstreamMaxRequest = Math.max(downstreamMaxRequest, rp.totalRequested.get());
<add> }
<ide>
<del> long diff = maxTotalRequests - ri;
<del> if (diff != 0L) {
<del> maxChildRequested = maxTotalRequests;
<del> if (p != null) {
<del> if (ur != 0L) {
<del> maxUpstreamRequested = 0L;
<del> p.request(ur + diff);
<del> } else {
<del> p.request(diff);
<del> }
<del> } else {
<del> // collect upstream request amounts until there is a producer for them
<del> long u = ur + diff;
<del> if (u < 0) {
<del> u = Long.MAX_VALUE;
<del> }
<del> maxUpstreamRequested = u;
<add> // how much more to request from the upstream
<add> long diff = downstreamMaxRequest - alreadyRequested;
<add> if (diff != 0L) {
<add> // save the new maximum requested
<add> requestedFromUpstream = downstreamMaxRequest;
<add> p.request(diff);
<ide> }
<del> } else
<del> // if there were outstanding upstream requests and we have a producer
<del> if (ur != 0L && p != null) {
<del> maxUpstreamRequested = 0L;
<del> // fire the accumulated requests
<del> p.request(ur);
<ide> }
<ide>
<del> missed = management.addAndGet(-missed);
<add> missed = m.addAndGet(-missed);
<ide> if (missed == 0) {
<ide> break;
<ide> }
<ide> public void replay(InnerSubscription<T> output) {
<ide> output.dispose();
<ide> if (!NotificationLite.isError(o) && !NotificationLite.isComplete(o)) {
<ide> child.onError(err);
<add> } else {
<add> RxJavaPlugins.onError(err);
<ide> }
<ide> return;
<ide> }
<ide> static final class Node extends AtomicReference<Node> {
<ide> *
<ide> * @param <T> the value type
<ide> */
<del> static class BoundedReplayBuffer<T> extends AtomicReference<Node> implements ReplayBuffer<T> {
<add> abstract static class BoundedReplayBuffer<T> extends AtomicReference<Node> implements ReplayBuffer<T> {
<ide>
<ide> private static final long serialVersionUID = 2346567790059478686L;
<ide>
<ide> public final void replay(InnerSubscription<T> output) {
<ide> output.emitting = true;
<ide> }
<ide> for (;;) {
<del> if (output.isDisposed()) {
<del> output.index = null;
<del> return;
<del> }
<del>
<ide> long r = output.get();
<ide> boolean unbounded = r == Long.MAX_VALUE; // NOPMD
<ide> long e = 0L;
<ide> public final void replay(InnerSubscription<T> output) {
<ide> }
<ide>
<ide> while (r != 0) {
<add> if (output.isDisposed()) {
<add> output.index = null;
<add> return;
<add> }
<add>
<ide> Node v = node.get();
<ide> if (v != null) {
<ide> Object o = leaveTransform(v.value);
<ide> public final void replay(InnerSubscription<T> output) {
<ide> output.dispose();
<ide> if (!NotificationLite.isError(o) && !NotificationLite.isComplete(o)) {
<ide> output.child.onError(err);
<add> } else {
<add> RxJavaPlugins.onError(err);
<ide> }
<ide> return;
<ide> }
<ide> public final void replay(InnerSubscription<T> output) {
<ide> } else {
<ide> break;
<ide> }
<del> if (output.isDisposed()) {
<del> output.index = null;
<del> return;
<del> }
<add> }
<add>
<add> if (r == 0 && output.isDisposed()) {
<add> output.index = null;
<add> return;
<ide> }
<ide>
<ide> if (e != 0L) {
<ide> Object leaveTransform(Object value) {
<ide> * Override this method to truncate a non-terminated buffer
<ide> * based on its current properties.
<ide> */
<del> void truncate() {
<del>
<del> }
<add> abstract void truncate();
<ide> /**
<ide> * Override this method to truncate a terminated buffer
<ide> * based on its properties (i.e., truncate but the very last node).
<ide> void truncate() {
<ide>
<ide> int e = 0;
<ide> for (;;) {
<del> if (next != null && size > 1) { // never truncate the very last item just added
<add> if (size > 1) { // never truncate the very last item just added
<ide> if (size > limit) {
<ide> e++;
<ide> size--;
<ide> void truncateFinal() {
<ide>
<ide> int e = 0;
<ide> for (;;) {
<del> if (next != null && size > 1) {
<add> if (size > 1) {
<ide> Timed<?> v = (Timed<?>)next.value;
<ide> if (v.time() <= timeLimit) {
<ide> e++;
<ide> public void accept(Disposable r) {
<ide> }
<ide> }
<ide>
<del> static final class ConnectableFlowableReplay<T> extends ConnectableFlowable<T> {
<del> private final ConnectableFlowable<T> cf;
<del> private final Flowable<T> flowable;
<del>
<del> ConnectableFlowableReplay(ConnectableFlowable<T> cf, Flowable<T> flowable) {
<del> this.cf = cf;
<del> this.flowable = flowable;
<del> }
<del>
<del> @Override
<del> public void connect(Consumer<? super Disposable> connection) {
<del> cf.connect(connection);
<del> }
<del>
<del> @Override
<del> public void reset() {
<del> cf.reset();
<del> }
<del>
<del> @Override
<del> protected void subscribeActual(Subscriber<? super T> s) {
<del> flowable.subscribe(s);
<del> }
<del> }
<del>
<ide> static final class ReplayBufferSupplier<T> implements Supplier<ReplayBuffer<T>> {
<ide>
<ide> final int bufferSize;
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableSwitchMap.java
<ide> public void cancel() {
<ide>
<ide> @SuppressWarnings("unchecked")
<ide> void disposeInner() {
<del> SwitchMapInnerSubscriber<T, R> a = active.get();
<del> if (a != CANCELLED) {
<del> a = active.getAndSet((SwitchMapInnerSubscriber<T, R>)CANCELLED);
<del> if (a != CANCELLED && a != null) {
<del> a.cancel();
<del> }
<add> SwitchMapInnerSubscriber<T, R> a = active.getAndSet((SwitchMapInnerSubscriber<T, R>)CANCELLED);
<add> if (a != CANCELLED && a != null) {
<add> a.cancel();
<ide> }
<ide> }
<ide>
<ide> void drain() {
<ide> SwitchMapInnerSubscriber<T, R> inner = active.get();
<ide> SimpleQueue<R> q = inner != null ? inner.queue : null;
<ide> if (q != null) {
<del> if (inner.done) {
<del> if (!delayErrors) {
<del> Throwable err = errors.get();
<del> if (err != null) {
<del> disposeInner();
<del> errors.tryTerminateConsumer(a);
<del> return;
<del> } else
<del> if (q.isEmpty()) {
<del> active.compareAndSet(inner, null);
<del> continue;
<del> }
<del> } else {
<del> if (q.isEmpty()) {
<del> active.compareAndSet(inner, null);
<del> continue;
<del> }
<del> }
<del> }
<del>
<ide> long r = requested.get();
<ide> long e = 0L;
<ide> boolean retry = false;
<ide> void drain() {
<ide> e++;
<ide> }
<ide>
<add> if (e == r) {
<add> if (inner.done) {
<add> if (!delayErrors) {
<add> Throwable err = errors.get();
<add> if (err != null) {
<add> disposeInner();
<add> errors.tryTerminateConsumer(a);
<add> return;
<add> } else
<add> if (q.isEmpty()) {
<add> active.compareAndSet(inner, null);
<add> continue;
<add> }
<add> } else {
<add> if (q.isEmpty()) {
<add> active.compareAndSet(inner, null);
<add> continue;
<add> }
<add> }
<add> }
<add> }
<add>
<ide> if (e != 0L) {
<ide> if (!cancelled) {
<ide> if (r != Long.MAX_VALUE) {
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTakeLast.java
<ide> void drain() {
<ide> a.onNext(v);
<ide> e++;
<ide> }
<del> if (e != 0L && r != Long.MAX_VALUE) {
<del> r = requested.addAndGet(-e);
<add> if (isEmpty()) {
<add> a.onComplete();
<add> return;
<add> }
<add> if (e != 0L) {
<add> r = BackpressureHelper.produced(requested, e);
<ide> }
<ide> }
<ide> } while (wip.decrementAndGet() != 0);
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableWindow.java
<ide> import io.reactivex.rxjava3.internal.queue.SpscLinkedArrayQueue;
<ide> import io.reactivex.rxjava3.internal.subscriptions.SubscriptionHelper;
<ide> import io.reactivex.rxjava3.internal.util.BackpressureHelper;
<del>import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<del>import io.reactivex.rxjava3.processors.*;
<add>import io.reactivex.rxjava3.processors.UnicastProcessor;
<ide>
<ide> public final class FlowableWindow<T> extends AbstractFlowableWithUpstream<T, Flowable<T>> {
<ide> final long size;
<ide> public void onSubscribe(Subscription s) {
<ide>
<ide> @Override
<ide> public void onNext(T t) {
<del> if (done) {
<del> return;
<del> }
<del>
<ide> long i = index;
<ide>
<ide> UnicastProcessor<T> newWindow = null;
<ide> public void onNext(T t) {
<ide>
<ide> @Override
<ide> public void onError(Throwable t) {
<del> if (done) {
<del> RxJavaPlugins.onError(t);
<del> return;
<del> }
<del>
<ide> for (Processor<T, T> w : windows) {
<ide> w.onError(t);
<ide> }
<ide> public void onError(Throwable t) {
<ide>
<ide> @Override
<ide> public void onComplete() {
<del> if (done) {
<del> return;
<del> }
<del>
<ide> for (Processor<T, T> w : windows) {
<ide> w.onComplete();
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableZip.java
<ide> void drain() {
<ide> for (int j = 0; j < n; j++) {
<ide> ZipSubscriber<T, R> inner = qs[j];
<ide> if (values[j] == null) {
<add> boolean d = inner.done;
<add> SimpleQueue<T> q = inner.queue;
<add> T v = null;
<ide> try {
<del> boolean d = inner.done;
<del> SimpleQueue<T> q = inner.queue;
<ide>
<del> T v = q != null ? q.poll() : null;
<del>
<del> boolean sourceEmpty = v == null;
<del> if (d && sourceEmpty) {
<del> cancelAll();
<del> errors.tryTerminateConsumer(a);
<del> return;
<del> }
<del> if (!sourceEmpty) {
<del> values[j] = v;
<del> } else {
<del> empty = true;
<del> }
<add> v = q != null ? q.poll() : null;
<ide> } catch (Throwable ex) {
<ide> Exceptions.throwIfFatal(ex);
<ide>
<ide> void drain() {
<ide> errors.tryTerminateConsumer(a);
<ide> return;
<ide> }
<add> d = true;
<add> }
<add>
<add> boolean sourceEmpty = v == null;
<add> if (d && sourceEmpty) {
<add> cancelAll();
<add> errors.tryTerminateConsumer(a);
<add> return;
<add> }
<add> if (!sourceEmpty) {
<add> values[j] = v;
<add> } else {
<ide> empty = true;
<ide> }
<ide> }
<ide> void drain() {
<ide> for (int j = 0; j < n; j++) {
<ide> ZipSubscriber<T, R> inner = qs[j];
<ide> if (values[j] == null) {
<add> boolean d = inner.done;
<add> SimpleQueue<T> q = inner.queue;
<add> T v = null;
<ide> try {
<del> boolean d = inner.done;
<del> SimpleQueue<T> q = inner.queue;
<del> T v = q != null ? q.poll() : null;
<del>
<del> boolean empty = v == null;
<del> if (d && empty) {
<del> cancelAll();
<del> errors.tryTerminateConsumer(a);
<del> return;
<del> }
<del> if (!empty) {
<del> values[j] = v;
<del> }
<add> v = q != null ? q.poll() : null;
<ide> } catch (Throwable ex) {
<ide> Exceptions.throwIfFatal(ex);
<ide> errors.tryAddThrowableOrReport(ex);
<ide> void drain() {
<ide> errors.tryTerminateConsumer(a);
<ide> return;
<ide> }
<add> d = true;
<add> }
<add> boolean empty = v == null;
<add> if (d && empty) {
<add> cancelAll();
<add> errors.tryTerminateConsumer(a);
<add> return;
<add> }
<add> if (!empty) {
<add> values[j] = v;
<ide> }
<ide> }
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableAmb.java
<ide> public boolean win(int index) {
<ide> }
<ide> return true;
<ide> }
<del> return false;
<ide> }
<del> return w == index;
<add> return false;
<ide> }
<ide>
<ide> @Override
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableBufferTimed.java
<ide> public void onSubscribe(Disposable d) {
<ide>
<ide> downstream.onSubscribe(this);
<ide>
<del> if (!cancelled) {
<add> if (!DisposableHelper.isDisposed(timer.get())) {
<ide> Disposable task = scheduler.schedulePeriodicallyDirect(this, timespan, timespan, unit);
<del> if (!timer.compareAndSet(null, task)) {
<del> task.dispose();
<del> }
<add> DisposableHelper.set(timer, task);
<ide> }
<ide> }
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableCombineLatest.java
<ide> public void subscribeActual(Observer<? super R> observer) {
<ide> int count = 0;
<ide> if (sources == null) {
<ide> sources = new ObservableSource[8];
<del> for (ObservableSource<? extends T> p : sourcesIterable) {
<del> if (count == sources.length) {
<del> ObservableSource<? extends T>[] b = new ObservableSource[count + (count >> 2)];
<del> System.arraycopy(sources, 0, b, 0, count);
<del> sources = b;
<add> try {
<add> for (ObservableSource<? extends T> p : sourcesIterable) {
<add> if (count == sources.length) {
<add> ObservableSource<? extends T>[] b = new ObservableSource[count + (count >> 2)];
<add> System.arraycopy(sources, 0, b, 0, count);
<add> sources = b;
<add> }
<add> sources[count++] = Objects.requireNonNull(p, "The Iterator returned a null ObservableSource");
<ide> }
<del> sources[count++] = p;
<add> } catch (Throwable ex) {
<add> Exceptions.throwIfFatal(ex);
<add> EmptyDisposable.error(ex, observer);
<add> return;
<ide> }
<ide> } else {
<ide> count = sources.length;
<ide> public void dispose() {
<ide> if (!cancelled) {
<ide> cancelled = true;
<ide> cancelSources();
<del> if (getAndIncrement() == 0) {
<del> clear(queue);
<del> }
<add> drain();
<ide> }
<ide> }
<ide>
<ide> void drain() {
<ide> for (;;) {
<ide> if (cancelled) {
<ide> clear(q);
<add> errors.tryTerminateAndReport();
<ide> return;
<ide> }
<ide>
<ide> void innerError(int index, Throwable ex) {
<ide> if (latest == null) {
<ide> return;
<ide> }
<del>
<ide> cancelOthers = latest[index] == null;
<ide> if (cancelOthers || ++complete == latest.length) {
<ide> done = true;
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableCreate.java
<ide> public String toString() {
<ide>
<ide> @Override
<ide> public void onNext(T t) {
<del> if (emitter.isDisposed() || done) {
<add> if (done || emitter.isDisposed()) {
<ide> return;
<ide> }
<ide> if (t == null) {
<ide> public void onError(Throwable t) {
<ide>
<ide> @Override
<ide> public boolean tryOnError(Throwable t) {
<del> if (emitter.isDisposed() || done) {
<add> if (done || emitter.isDisposed()) {
<ide> return false;
<ide> }
<ide> if (t == null) {
<ide> public boolean tryOnError(Throwable t) {
<ide>
<ide> @Override
<ide> public void onComplete() {
<del> if (emitter.isDisposed() || done) {
<add> if (done || emitter.isDisposed()) {
<ide> return;
<ide> }
<ide> done = true;
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFlatMap.java
<ide> public void subscribeActual(Observer<? super U> t) {
<ide>
<ide> final AtomicThrowable errors = new AtomicThrowable();
<ide>
<del> volatile boolean cancelled;
<add> volatile boolean disposed;
<ide>
<ide> final AtomicReference<InnerObserver<?, ?>[]> observers;
<ide>
<ide> public void subscribeActual(Observer<? super U> t) {
<ide> Disposable upstream;
<ide>
<ide> long uniqueId;
<del> long lastId;
<ide> int lastIndex;
<ide>
<ide> Queue<ObservableSource<? extends U>> sources;
<ide> void removeInner(InnerObserver<T, U> inner) {
<ide> for (;;) {
<ide> InnerObserver<?, ?>[] a = observers.get();
<ide> int n = a.length;
<del> if (n == 0) {
<del> return;
<del> }
<ide> int j = -1;
<ide> for (int i = 0; i < n; i++) {
<ide> if (a[i] == inner) {
<ide> boolean tryEmitScalar(Supplier<? extends U> value) {
<ide> queue = q;
<ide> }
<ide>
<del> if (!q.offer(u)) {
<del> onError(new IllegalStateException("Scalar queue full?!"));
<del> return true;
<del> }
<add> q.offer(u);
<ide> if (getAndIncrement() != 0) {
<ide> return false;
<ide> }
<ide> public void onComplete() {
<ide>
<ide> @Override
<ide> public void dispose() {
<del> if (!cancelled) {
<del> cancelled = true;
<del> if (disposeAll()) {
<del> errors.tryTerminateAndReport();
<del> }
<add> disposed = true;
<add> if (disposeAll()) {
<add> errors.tryTerminateAndReport();
<ide> }
<ide> }
<ide>
<ide> @Override
<ide> public boolean isDisposed() {
<del> return cancelled;
<add> return disposed;
<ide> }
<ide>
<ide> void drain() {
<ide> void drainLoop() {
<ide>
<ide> int innerCompleted = 0;
<ide> if (n != 0) {
<del> long startId = lastId;
<del> int index = lastIndex;
<del>
<del> if (n <= index || inner[index].id != startId) {
<del> if (n <= index) {
<del> index = 0;
<del> }
<del> int j = index;
<del> for (int i = 0; i < n; i++) {
<del> if (inner[j].id == startId) {
<del> break;
<del> }
<del> j++;
<del> if (j == n) {
<del> j = 0;
<del> }
<del> }
<del> index = j;
<del> lastIndex = j;
<del> lastId = inner[j].id;
<del> }
<add> int j = Math.min(n - 1, lastIndex);
<ide>
<del> int j = index;
<ide> sourceLoop:
<ide> for (int i = 0; i < n; i++) {
<ide> if (checkTerminate()) {
<ide> void drainLoop() {
<ide> SimpleQueue<U> innerQueue = is.queue;
<ide> if (innerDone && (innerQueue == null || innerQueue.isEmpty())) {
<ide> removeInner(is);
<del> if (checkTerminate()) {
<del> return;
<del> }
<ide> innerCompleted++;
<ide> }
<ide>
<ide> void drainLoop() {
<ide> }
<ide> }
<ide> lastIndex = j;
<del> lastId = inner[j].id;
<ide> }
<ide>
<ide> if (innerCompleted != 0) {
<ide> void drainLoop() {
<ide> }
<ide>
<ide> boolean checkTerminate() {
<del> if (cancelled) {
<add> if (disposed) {
<ide> return true;
<ide> }
<ide> Throwable e = errors.get();
<ide> boolean checkTerminate() {
<ide>
<ide> boolean disposeAll() {
<ide> upstream.dispose();
<del> InnerObserver<?, ?>[] a = observers.get();
<add> InnerObserver<?, ?>[] a = observers.getAndSet(CANCELLED);
<ide> if (a != CANCELLED) {
<del> a = observers.getAndSet(CANCELLED);
<del> if (a != CANCELLED) {
<del> for (InnerObserver<?, ?> inner : a) {
<del> inner.dispose();
<del> }
<del> return true;
<add> for (InnerObserver<?, ?> inner : a) {
<add> inner.dispose();
<ide> }
<add> return true;
<ide> }
<ide> return false;
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFlatMapCompletable.java
<ide> public void onError(Throwable e) {
<ide> disposed = true;
<ide> upstream.dispose();
<ide> set.dispose();
<del> if (getAndSet(0) > 0) {
<del> errors.tryTerminateConsumer(downstream);
<del> }
<add> errors.tryTerminateConsumer(downstream);
<ide> }
<ide> }
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFlatMapCompletableCompletable.java
<ide> public void onError(Throwable e) {
<ide> disposed = true;
<ide> upstream.dispose();
<ide> set.dispose();
<del> if (getAndSet(0) > 0) {
<del> errors.tryTerminateConsumer(downstream);
<del> }
<add> errors.tryTerminateConsumer(downstream);
<ide> }
<ide> }
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFlatMapMaybe.java
<ide> void innerSuccess(InnerObserver inner, R value) {
<ide> }
<ide>
<ide> SpscLinkedArrayQueue<R> getOrCreateQueue() {
<del> for (;;) {
<del> SpscLinkedArrayQueue<R> current = queue.get();
<del> if (current != null) {
<del> return current;
<del> }
<del> current = new SpscLinkedArrayQueue<>(Observable.bufferSize());
<del> if (queue.compareAndSet(null, current)) {
<del> return current;
<del> }
<add> SpscLinkedArrayQueue<R> current = queue.get();
<add> if (current != null) {
<add> return current;
<add> }
<add> current = new SpscLinkedArrayQueue<>(Observable.bufferSize());
<add> if (queue.compareAndSet(null, current)) {
<add> return current;
<ide> }
<add> return queue.get();
<ide> }
<ide>
<ide> void innerError(InnerObserver inner, Throwable e) {
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFlatMapSingle.java
<ide> void innerSuccess(InnerObserver inner, R value) {
<ide> }
<ide>
<ide> SpscLinkedArrayQueue<R> getOrCreateQueue() {
<del> for (;;) {
<del> SpscLinkedArrayQueue<R> current = queue.get();
<del> if (current != null) {
<del> return current;
<del> }
<del> current = new SpscLinkedArrayQueue<>(Observable.bufferSize());
<del> if (queue.compareAndSet(null, current)) {
<del> return current;
<del> }
<add> SpscLinkedArrayQueue<R> current = queue.get();
<add> if (current != null) {
<add> return current;
<add> }
<add> current = new SpscLinkedArrayQueue<>(Observable.bufferSize());
<add> if (queue.compareAndSet(null, current)) {
<add> return current;
<ide> }
<add> return queue.get();
<ide> }
<ide>
<ide> void innerError(InnerObserver inner, Throwable e) {
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableGroupJoin.java
<ide> else if (mode == LEFT_CLOSE) {
<ide> up.onComplete();
<ide> }
<ide> }
<del> else if (mode == RIGHT_CLOSE) {
<add> else {
<ide> LeftRightEndObserver end = (LeftRightEndObserver)val;
<ide>
<ide> rights.remove(end.index);
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableIntervalRange.java
<ide> public void run() {
<ide> downstream.onNext(c);
<ide>
<ide> if (c == end) {
<add> if (!isDisposed()) {
<add> downstream.onComplete();
<add> }
<ide> DisposableHelper.dispose(this);
<del> downstream.onComplete();
<ide> return;
<ide> }
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableReplay.java
<ide> void truncate() {
<ide>
<ide> int e = 0;
<ide> for (;;) {
<del> if (next != null && size > 1) { // never truncate the very last item just added
<add> if (size > 1) { // never truncate the very last item just added
<ide> if (size > limit) {
<ide> e++;
<ide> size--;
<ide> void truncateFinal() {
<ide>
<ide> int e = 0;
<ide> for (;;) {
<del> if (next != null && size > 1) {
<add> if (size > 1) {
<ide> Timed<?> v = (Timed<?>)next.value;
<ide> if (v.time() <= timeLimit) {
<ide> e++;
<ide> protected void subscribeActual(Observer<? super R> child) {
<ide> co.connect(new DisposeConsumer<>(srw));
<ide> }
<ide> }
<del>
<del> static final class Replay<T> extends ConnectableObservable<T> {
<del> private final ConnectableObservable<T> co;
<del> private final Observable<T> observable;
<del>
<del> Replay(ConnectableObservable<T> co, Observable<T> observable) {
<del> this.co = co;
<del> this.observable = observable;
<del> }
<del>
<del> @Override
<del> public void connect(Consumer<? super Disposable> connection) {
<del> co.connect(connection);
<del> }
<del>
<del> @Override
<del> public void reset() {
<del> co.reset();
<del> }
<del>
<del> @Override
<del> protected void subscribeActual(Observer<? super T> observer) {
<del> observable.subscribe(observer);
<del> }
<del> }
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSwitchMap.java
<ide> public boolean isDisposed() {
<ide>
<ide> @SuppressWarnings("unchecked")
<ide> void disposeInner() {
<del> SwitchMapInnerObserver<T, R> a = active.get();
<del> if (a != CANCELLED) {
<del> a = active.getAndSet((SwitchMapInnerObserver<T, R>)CANCELLED);
<del> if (a != CANCELLED && a != null) {
<del> a.cancel();
<del> }
<add> SwitchMapInnerObserver<T, R> a = active.getAndSet((SwitchMapInnerObserver<T, R>)CANCELLED);
<add> if (a != null) {
<add> a.cancel();
<ide> }
<ide> }
<ide>
<ide> void drain() {
<ide> SimpleQueue<R> q = inner.queue;
<ide>
<ide> if (q != null) {
<del> if (inner.done) {
<del> boolean empty = q.isEmpty();
<del> if (delayErrors) {
<del> if (empty) {
<del> active.compareAndSet(inner, null);
<del> continue;
<del> }
<del> } else {
<del> Throwable ex = errors.get();
<del> if (ex != null) {
<del> errors.tryTerminateConsumer(a);
<del> return;
<del> }
<del> if (empty) {
<del> active.compareAndSet(inner, null);
<del> continue;
<del> }
<del> }
<del> }
<ide>
<ide> boolean retry = false;
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeLast.java
<ide> public void onComplete() {
<ide> }
<ide> T v = poll();
<ide> if (v == null) {
<del> if (!cancelled) {
<del> a.onComplete();
<del> }
<add> a.onComplete();
<ide> return;
<ide> }
<ide> a.onNext(v);
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableThrottleFirstTimed.java
<ide> import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
<ide> import io.reactivex.rxjava3.observers.SerializedObserver;
<del>import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide>
<ide> public final class ObservableThrottleFirstTimed<T> extends AbstractObservableWithUpstream<T, T> {
<ide> final long timeout;
<ide> public void subscribeActual(Observer<? super T> t) {
<ide>
<ide> volatile boolean gate;
<ide>
<del> boolean done;
<del>
<ide> DebounceTimedObserver(Observer<? super T> actual, long timeout, TimeUnit unit, Worker worker) {
<ide> this.downstream = actual;
<ide> this.timeout = timeout;
<ide> public void onSubscribe(Disposable d) {
<ide>
<ide> @Override
<ide> public void onNext(T t) {
<del> if (!gate && !done) {
<add> if (!gate) {
<ide> gate = true;
<ide>
<ide> downstream.onNext(t);
<ide> public void run() {
<ide>
<ide> @Override
<ide> public void onError(Throwable t) {
<del> if (done) {
<del> RxJavaPlugins.onError(t);
<del> } else {
<del> done = true;
<del> downstream.onError(t);
<del> worker.dispose();
<del> }
<add> downstream.onError(t);
<add> worker.dispose();
<ide> }
<ide>
<ide> @Override
<ide> public void onComplete() {
<del> if (!done) {
<del> done = true;
<del> downstream.onComplete();
<del> worker.dispose();
<del> }
<add> downstream.onComplete();
<add> worker.dispose();
<ide> }
<ide>
<ide> @Override
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableToList.java
<ide> import io.reactivex.rxjava3.exceptions.Exceptions;
<ide> import io.reactivex.rxjava3.functions.Supplier;
<ide> import io.reactivex.rxjava3.internal.disposables.*;
<del>import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.util.ExceptionHelper;
<ide>
<ide> public final class ObservableToList<T, U extends Collection<? super T>>
<ide> extends AbstractObservableWithUpstream<T, U> {
<ide>
<ide> final Supplier<U> collectionSupplier;
<ide>
<del> @SuppressWarnings({ "unchecked", "rawtypes" })
<del> public ObservableToList(ObservableSource<T> source, final int defaultCapacityHint) {
<del> super(source);
<del> this.collectionSupplier = (Supplier)Functions.createArrayList(defaultCapacityHint);
<del> }
<del>
<ide> public ObservableToList(ObservableSource<T> source, Supplier<U> collectionSupplier) {
<ide> super(source);
<ide> this.collectionSupplier = collectionSupplier;
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/parallel/ParallelFromPublisher.java
<ide> void setupSubscribers() {
<ide> final int m = subs.length;
<ide>
<ide> for (int i = 0; i < m; i++) {
<del> if (cancelled) {
<del> return;
<del> }
<del>
<ide> subscriberCount.lazySet(i + 1);
<ide>
<ide> subs[i].onSubscribe(new RailSubscription(i, m));
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/parallel/ParallelJoin.java
<ide> void drainLoop() {
<ide> }
<ide> }
<ide>
<del> if (e != 0 && r != Long.MAX_VALUE) {
<del> requested.addAndGet(-e);
<add> if (e != 0) {
<add> BackpressureHelper.produced(requested, e);
<ide> }
<ide>
<del> int w = get();
<del> if (w == missed) {
<del> missed = addAndGet(-missed);
<del> if (missed == 0) {
<del> break;
<del> }
<del> } else {
<del> missed = w;
<add> missed = addAndGet(-missed);
<add> if (missed == 0) {
<add> break;
<ide> }
<ide> }
<ide> }
<ide> void onNext(JoinInnerSubscriber<T> inner, T value) {
<ide> SimplePlainQueue<T> q = inner.getQueue();
<ide>
<ide> if (!q.offer(value)) {
<del> if (inner.cancel()) {
<del> errors.tryAddThrowableOrReport(new MissingBackpressureException("Queue full?!"));
<del> done.decrementAndGet();
<del> }
<add> inner.cancel();
<add> errors.tryAddThrowableOrReport(new MissingBackpressureException("Queue full?!"));
<add> done.decrementAndGet();
<ide> }
<ide>
<ide> if (getAndIncrement() != 0) {
<ide> void drainLoop() {
<ide> }
<ide> }
<ide>
<del> if (e != 0 && r != Long.MAX_VALUE) {
<del> requested.addAndGet(-e);
<add> if (e != 0) {
<add> BackpressureHelper.produced(requested, e);
<ide> }
<ide>
<del> int w = get();
<del> if (w == missed) {
<del> missed = addAndGet(-missed);
<del> if (missed == 0) {
<del> break;
<del> }
<del> } else {
<del> missed = w;
<add> missed = addAndGet(-missed);
<add> if (missed == 0) {
<add> break;
<ide> }
<ide> }
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/parallel/ParallelRunOn.java
<ide> public void run() {
<ide> }
<ide> }
<ide>
<del> if (e != 0L && r != Long.MAX_VALUE) {
<del> requested.addAndGet(-e);
<add> if (e != 0L) {
<add> BackpressureHelper.produced(requested, e);
<ide> }
<ide>
<del> int w = get();
<del> if (w == missed) {
<del> consumed = c;
<del> missed = addAndGet(-missed);
<del> if (missed == 0) {
<del> break;
<del> }
<del> } else {
<del> missed = w;
<add> consumed = c;
<add> missed = addAndGet(-missed);
<add> if (missed == 0) {
<add> break;
<ide> }
<ide> }
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/parallel/ParallelSortedJoin.java
<ide> void drain() {
<ide> e++;
<ide> }
<ide>
<del> if (e == r) {
<del> if (cancelled) {
<del> Arrays.fill(lists, null);
<del> return;
<del> }
<add> if (cancelled) {
<add> Arrays.fill(lists, null);
<add> return;
<add> }
<ide>
<del> Throwable ex = error.get();
<del> if (ex != null) {
<del> cancelAll();
<del> Arrays.fill(lists, null);
<del> a.onError(ex);
<del> return;
<del> }
<add> Throwable ex = error.get();
<add> if (ex != null) {
<add> cancelAll();
<add> Arrays.fill(lists, null);
<add> a.onError(ex);
<add> return;
<add> }
<ide>
<del> boolean empty = true;
<add> boolean empty = true;
<ide>
<del> for (int i = 0; i < n; i++) {
<del> if (indexes[i] != lists[i].size()) {
<del> empty = false;
<del> break;
<del> }
<add> for (int i = 0; i < n; i++) {
<add> if (indexes[i] != lists[i].size()) {
<add> empty = false;
<add> break;
<ide> }
<add> }
<ide>
<del> if (empty) {
<del> Arrays.fill(lists, null);
<del> a.onComplete();
<del> return;
<del> }
<add> if (empty) {
<add> Arrays.fill(lists, null);
<add> a.onComplete();
<add> return;
<ide> }
<ide>
<del> if (e != 0 && r != Long.MAX_VALUE) {
<del> requested.addAndGet(-e);
<add> if (e != 0) {
<add> BackpressureHelper.produced(requested, e);
<ide> }
<ide>
<del> int w = get();
<del> if (w == missed) {
<del> missed = addAndGet(-missed);
<del> if (missed == 0) {
<del> break;
<del> }
<del> } else {
<del> missed = w;
<add> missed = addAndGet(-missed);
<add> if (missed == 0) {
<add> break;
<ide> }
<ide> }
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/single/SingleDelayWithObservable.java
<ide> protected void subscribeActual(SingleObserver<? super T> observer) {
<ide>
<ide> @Override
<ide> public void onSubscribe(Disposable d) {
<del> if (DisposableHelper.set(this, d)) {
<add> if (DisposableHelper.setOnce(this, d)) {
<ide>
<ide> downstream.onSubscribe(this);
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/single/SingleEquals.java
<ide> public void onSuccess(T value) {
<ide>
<ide> @Override
<ide> public void onError(Throwable e) {
<del> for (;;) {
<del> int state = count.get();
<del> if (state >= 2) {
<del> RxJavaPlugins.onError(e);
<del> return;
<del> }
<del> if (count.compareAndSet(state, 2)) {
<del> set.dispose();
<del> downstream.onError(e);
<del> return;
<del> }
<add> int state = count.getAndSet(-1);
<add> if (state == 0 || state == 1) {
<add> set.dispose();
<add> downstream.onError(e);
<add> } else {
<add> RxJavaPlugins.onError(e);
<ide> }
<ide> }
<del>
<ide> }
<del>
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/single/SingleFlatMapIterableFlowable.java
<ide> void drain() {
<ide> long e = 0L;
<ide>
<ide> if (r == Long.MAX_VALUE) {
<del> slowPath(a, iterator);
<add> fastPath(a, iterator);
<ide> return;
<ide> }
<ide>
<ide> void drain() {
<ide> }
<ide> }
<ide>
<del> void slowPath(Subscriber<? super R> a, Iterator<? extends R> iterator) {
<add> void fastPath(Subscriber<? super R> a, Iterator<? extends R> iterator) {
<ide> for (;;) {
<ide> if (cancelled) {
<ide> return;
<ide><path>src/main/java/io/reactivex/rxjava3/internal/operators/single/SingleInternalHelper.java
<ide> package io.reactivex.rxjava3.internal.operators.single;
<ide>
<ide> import java.util.*;
<del>import java.util.concurrent.Callable;
<ide>
<ide> import org.reactivestreams.Publisher;
<ide>
<ide> private SingleInternalHelper() {
<ide> throw new IllegalStateException("No instances!");
<ide> }
<ide>
<del> enum NoSuchElementCallable implements Supplier<NoSuchElementException>, Callable<NoSuchElementException> {
<add> enum NoSuchElementSupplier implements Supplier<NoSuchElementException> {
<ide> INSTANCE;
<ide>
<del> @Override
<del> public NoSuchElementException call() {
<del> return new NoSuchElementException();
<del> }
<del>
<ide> @Override
<ide> public NoSuchElementException get() {
<ide> return new NoSuchElementException();
<ide> }
<ide> }
<ide>
<ide> public static Supplier<NoSuchElementException> emptyThrower() {
<del> return NoSuchElementCallable.INSTANCE;
<add> return NoSuchElementSupplier.INSTANCE;
<ide> }
<ide>
<ide> @SuppressWarnings("rawtypes")
<ide><path>src/main/java/io/reactivex/rxjava3/internal/schedulers/ComputationScheduler.java
<ide> public void start() {
<ide>
<ide> @Override
<ide> public void shutdown() {
<del> for (;;) {
<del> FixedSchedulerPool curr = pool.get();
<del> if (curr == NONE) {
<del> return;
<del> }
<del> if (pool.compareAndSet(curr, NONE)) {
<del> curr.shutdown();
<del> return;
<del> }
<add> FixedSchedulerPool curr = pool.getAndSet(NONE);
<add> if (curr != NONE) {
<add> curr.shutdown();
<ide> }
<ide> }
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/schedulers/ExecutorScheduler.java
<ide> void runFair() {
<ide> }
<ide>
<ide> Runnable run = q.poll();
<del> if (run != null) {
<del> run.run();
<del> }
<add> run.run(); // never null because of offer + increment happens first
<ide>
<ide> if (disposed) {
<ide> q.clear();
<ide><path>src/main/java/io/reactivex/rxjava3/internal/schedulers/IoScheduler.java
<ide> static final class CachedWorkerPool implements Runnable {
<ide>
<ide> @Override
<ide> public void run() {
<del> evictExpiredWorkers();
<add> evictExpiredWorkers(expiringWorkerQueue, allWorkers);
<ide> }
<ide>
<ide> ThreadWorker get() {
<ide> void release(ThreadWorker threadWorker) {
<ide> expiringWorkerQueue.offer(threadWorker);
<ide> }
<ide>
<del> void evictExpiredWorkers() {
<add> static void evictExpiredWorkers(ConcurrentLinkedQueue<ThreadWorker> expiringWorkerQueue, CompositeDisposable allWorkers) {
<ide> if (!expiringWorkerQueue.isEmpty()) {
<ide> long currentTimestamp = now();
<ide>
<ide> void evictExpiredWorkers() {
<ide> }
<ide> }
<ide>
<del> long now() {
<add> static long now() {
<ide> return System.nanoTime();
<ide> }
<ide>
<ide> public void start() {
<ide>
<ide> @Override
<ide> public void shutdown() {
<del> for (;;) {
<del> CachedWorkerPool curr = pool.get();
<del> if (curr == NONE) {
<del> return;
<del> }
<del> if (pool.compareAndSet(curr, NONE)) {
<del> curr.shutdown();
<del> return;
<del> }
<add> CachedWorkerPool curr = pool.getAndSet(NONE);
<add> if (curr != NONE) {
<add> curr.shutdown();
<ide> }
<ide> }
<ide>
<ide> public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull Ti
<ide> }
<ide>
<ide> static final class ThreadWorker extends NewThreadWorker {
<del> private long expirationTime;
<add>
<add> long expirationTime;
<ide>
<ide> ThreadWorker(ThreadFactory threadFactory) {
<ide> super(threadFactory);
<ide><path>src/main/java/io/reactivex/rxjava3/internal/schedulers/SchedulerWhen.java
<ide> public boolean isDisposed() {
<ide>
<ide> @Override
<ide> public void dispose() {
<del> Disposable oldState;
<del> // no matter what the current state is the new state is going to be
<del> Disposable newState = DISPOSED;
<del> do {
<del> oldState = get();
<del> if (oldState == DISPOSED) {
<del> // the action has already been unsubscribed
<del> return;
<del> }
<del> } while (!compareAndSet(oldState, newState));
<del>
<del> if (oldState != SUBSCRIBED) {
<del> // the action was scheduled. stop it.
<del> oldState.dispose();
<del> }
<add> getAndSet(DISPOSED).dispose();
<ide> }
<ide> }
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/schedulers/SingleScheduler.java
<ide> public void start() {
<ide>
<ide> @Override
<ide> public void shutdown() {
<del> ScheduledExecutorService current = executor.get();
<add> ScheduledExecutorService current = executor.getAndSet(SHUTDOWN);
<ide> if (current != SHUTDOWN) {
<del> current = executor.getAndSet(SHUTDOWN);
<del> if (current != SHUTDOWN) {
<del> current.shutdownNow();
<del> }
<add> current.shutdownNow();
<ide> }
<ide> }
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/subscribers/FutureSubscriber.java
<ide> import java.util.concurrent.*;
<ide> import java.util.concurrent.atomic.AtomicReference;
<ide>
<del>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import org.reactivestreams.Subscription;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.FlowableSubscriber;
<ide> import io.reactivex.rxjava3.internal.subscriptions.SubscriptionHelper;
<ide> import io.reactivex.rxjava3.internal.util.BlockingHelper;
<ide> public void onNext(T t) {
<ide>
<ide> @Override
<ide> public void onError(Throwable t) {
<del> for (;;) {
<add> if (error == null) {
<ide> Subscription a = upstream.get();
<del> if (a == this || a == SubscriptionHelper.CANCELLED) {
<del> RxJavaPlugins.onError(t);
<del> return;
<del> }
<del> error = t;
<del> if (upstream.compareAndSet(a, this)) {
<add> if (a != this && a != SubscriptionHelper.CANCELLED
<add> && upstream.compareAndSet(a, this)) {
<add> error = t;
<ide> countDown();
<ide> return;
<ide> }
<ide> }
<add> RxJavaPlugins.onError(t);
<ide> }
<ide>
<ide> @Override
<ide> public void onComplete() {
<ide> onError(new NoSuchElementException("The source is empty"));
<ide> return;
<ide> }
<del> for (;;) {
<del> Subscription a = upstream.get();
<del> if (a == this || a == SubscriptionHelper.CANCELLED) {
<del> return;
<del> }
<del> if (upstream.compareAndSet(a, this)) {
<del> countDown();
<del> return;
<del> }
<add> Subscription a = upstream.get();
<add> if (a == this || a == SubscriptionHelper.CANCELLED) {
<add> return;
<add> }
<add> if (upstream.compareAndSet(a, this)) {
<add> countDown();
<ide> }
<ide> }
<ide>
<ide><path>src/main/java/io/reactivex/rxjava3/internal/subscribers/InnerQueuedSubscriber.java
<ide> public void request(long n) {
<ide> }
<ide> }
<ide>
<del> public void requestOne() {
<del> if (fusionMode != QueueSubscription.SYNC) {
<del> long p = produced + 1;
<del> if (p == limit) {
<del> produced = 0L;
<del> get().request(p);
<del> } else {
<del> produced = p;
<del> }
<del> }
<del> }
<del>
<ide> @Override
<ide> public void cancel() {
<ide> SubscriptionHelper.cancel(this);
<ide><path>src/main/java/io/reactivex/rxjava3/internal/util/HalfSerializer.java
<ide> private HalfSerializer() {
<ide> * @param value the value to emit
<ide> * @param wip the serialization work-in-progress counter/indicator
<ide> * @param errors the holder of Throwables
<add> * @return true if the operation succeeded, false if there sequence completed
<ide> */
<del> public static <T> void onNext(Subscriber<? super T> subscriber, T value,
<add> public static <T> boolean onNext(Subscriber<? super T> subscriber, T value,
<ide> AtomicInteger wip, AtomicThrowable errors) {
<ide> if (wip.get() == 0 && wip.compareAndSet(0, 1)) {
<ide> subscriber.onNext(value);
<del> if (wip.decrementAndGet() != 0) {
<del> errors.tryTerminateConsumer(subscriber);
<add> if (wip.decrementAndGet() == 0) {
<add> return true;
<ide> }
<add> errors.tryTerminateConsumer(subscriber);
<ide> }
<add> return false;
<ide> }
<ide>
<ide> /**
<ide><path>src/main/java/io/reactivex/rxjava3/processors/BehaviorProcessor.java
<ide> void remove(BehaviorSubscription<T> rs) {
<ide> @SuppressWarnings("unchecked")
<ide> BehaviorSubscription<T>[] terminate(Object terminalValue) {
<ide>
<del> BehaviorSubscription<T>[] a = subscribers.get();
<del> if (a != TERMINATED) {
<del> a = subscribers.getAndSet(TERMINATED);
<del> if (a != TERMINATED) {
<del> // either this or atomics with lots of allocation
<del> setCurrent(terminalValue);
<del> }
<del> }
<add> setCurrent(terminalValue);
<ide>
<del> return a;
<add> return subscribers.getAndSet(TERMINATED);
<ide> }
<ide>
<ide> void setCurrent(Object o) {
<ide><path>src/main/java/io/reactivex/rxjava3/processors/MulticastProcessor.java
<ide> import io.reactivex.rxjava3.internal.fuseable.*;
<ide> import io.reactivex.rxjava3.internal.queue.*;
<ide> import io.reactivex.rxjava3.internal.subscriptions.*;
<del>import io.reactivex.rxjava3.internal.util.ExceptionHelper;
<add>import io.reactivex.rxjava3.internal.util.*;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide>
<ide> /**
<ide>
<ide> final AtomicReference<MulticastSubscription<T>[]> subscribers;
<ide>
<del> final AtomicBoolean once;
<del>
<ide> final int bufferSize;
<ide>
<ide> final int limit;
<ide> public static <T> MulticastProcessor<T> create(int bufferSize, boolean refCount)
<ide> this.subscribers = new AtomicReference<>(EMPTY);
<ide> this.upstream = new AtomicReference<>();
<ide> this.refcount = refCount;
<del> this.once = new AtomicBoolean();
<ide> }
<ide>
<ide> /**
<ide> public void onSubscribe(@NonNull Subscription s) {
<ide>
<ide> @Override
<ide> public void onNext(@NonNull T t) {
<del> if (once.get()) {
<add> if (done) {
<ide> return;
<ide> }
<ide> if (fusionMode == QueueSubscription.NONE) {
<ide> public void onNext(@NonNull T t) {
<ide> @CheckReturnValue
<ide> public boolean offer(@NonNull T t) {
<ide> ExceptionHelper.nullCheck(t, "offer called with a null value.");
<del> if (once.get()) {
<add> if (done) {
<ide> return false;
<ide> }
<ide> if (fusionMode == QueueSubscription.NONE) {
<ide> public boolean offer(@NonNull T t) {
<ide> @Override
<ide> public void onError(@NonNull Throwable t) {
<ide> ExceptionHelper.nullCheck(t, "onError called with a null Throwable.");
<del> if (once.compareAndSet(false, true)) {
<add> if (!done) {
<ide> error = t;
<ide> done = true;
<ide> drain();
<del> } else {
<del> RxJavaPlugins.onError(t);
<add> return;
<ide> }
<add> RxJavaPlugins.onError(t);
<ide> }
<ide>
<ide> @Override
<ide> public void onComplete() {
<del> if (once.compareAndSet(false, true)) {
<del> done = true;
<del> drain();
<del> }
<add> done = true;
<add> drain();
<ide> }
<ide>
<ide> @Override
<ide> public boolean hasSubscribers() {
<ide> @Override
<ide> @CheckReturnValue
<ide> public boolean hasThrowable() {
<del> return once.get() && error != null;
<add> return done && error != null;
<ide> }
<ide>
<ide> @Override
<ide> @CheckReturnValue
<ide> public boolean hasComplete() {
<del> return once.get() && error == null;
<add> return done && error == null;
<ide> }
<ide>
<ide> @Override
<ide> @CheckReturnValue
<ide> public Throwable getThrowable() {
<del> return once.get() ? error : null;
<add> return done ? error : null;
<ide> }
<ide>
<ide> @Override
<ide> protected void subscribeActual(@NonNull Subscriber<@NonNull ? super T> s) {
<ide> drain();
<ide> }
<ide> } else {
<del> if (once.get() || !refcount) {
<add> if (done) {
<ide> Throwable ex = error;
<ide> if (ex != null) {
<ide> s.onError(ex);
<ide> void remove(MulticastSubscription<T> inner) {
<ide> if (refcount) {
<ide> if (subscribers.compareAndSet(a, TERMINATED)) {
<ide> SubscriptionHelper.cancel(upstream);
<del> once.set(true);
<add> done = true;
<ide> break;
<ide> }
<ide> } else {
<ide> void drain() {
<ide> @Override
<ide> public void request(long n) {
<ide> if (SubscriptionHelper.validate(n)) {
<del> for (;;) {
<del> long r = get();
<del> if (r == Long.MIN_VALUE || r == Long.MAX_VALUE) {
<del> break;
<del> }
<del> long u = r + n;
<del> if (u < 0L) {
<del> u = Long.MAX_VALUE;
<del> }
<del> if (compareAndSet(r, u)) {
<del> parent.drain();
<del> break;
<del> }
<add> long r = BackpressureHelper.addCancel(this, n);
<add> if (r != Long.MIN_VALUE && r != Long.MAX_VALUE) {
<add> parent.drain();
<ide> }
<ide> }
<ide> }
<ide><path>src/main/java/io/reactivex/rxjava3/processors/ReplayProcessor.java
<ide> void trim() {
<ide> break;
<ide> }
<ide> TimedNode<T> next = h.get();
<del> if (next == null) {
<del> head = h;
<del> break;
<del> }
<ide>
<ide> if (next.time > limit) {
<ide> head = h;
<ide><path>src/main/java/io/reactivex/rxjava3/subjects/BehaviorSubject.java
<ide>
<ide> final AtomicReference<Object> value;
<ide>
<del> final AtomicReference<BehaviorDisposable<T>[]> subscribers;
<add> final AtomicReference<BehaviorDisposable<T>[]> observers;
<ide>
<ide> @SuppressWarnings("rawtypes")
<ide> static final BehaviorDisposable[] EMPTY = new BehaviorDisposable[0];
<ide> public static <T> BehaviorSubject<T> create() {
<ide> this.lock = new ReentrantReadWriteLock();
<ide> this.readLock = lock.readLock();
<ide> this.writeLock = lock.writeLock();
<del> this.subscribers = new AtomicReference<>(EMPTY);
<add> this.observers = new AtomicReference<>(EMPTY);
<ide> this.value = new AtomicReference<>(defaultValue);
<ide> this.terminalEvent = new AtomicReference<>();
<ide> }
<ide> public void onNext(T t) {
<ide> }
<ide> Object o = NotificationLite.next(t);
<ide> setCurrent(o);
<del> for (BehaviorDisposable<T> bs : subscribers.get()) {
<add> for (BehaviorDisposable<T> bs : observers.get()) {
<ide> bs.emitNext(o, index);
<ide> }
<ide> }
<ide> public void onComplete() {
<ide> @Override
<ide> @CheckReturnValue
<ide> public boolean hasObservers() {
<del> return subscribers.get().length != 0;
<add> return observers.get().length != 0;
<ide> }
<ide>
<ide> @CheckReturnValue
<ide> /* test support*/ int subscriberCount() {
<del> return subscribers.get().length;
<add> return observers.get().length;
<ide> }
<ide>
<ide> @Override
<ide> public boolean hasValue() {
<ide>
<ide> boolean add(BehaviorDisposable<T> rs) {
<ide> for (;;) {
<del> BehaviorDisposable<T>[] a = subscribers.get();
<add> BehaviorDisposable<T>[] a = observers.get();
<ide> if (a == TERMINATED) {
<ide> return false;
<ide> }
<ide> boolean add(BehaviorDisposable<T> rs) {
<ide> BehaviorDisposable<T>[] b = new BehaviorDisposable[len + 1];
<ide> System.arraycopy(a, 0, b, 0, len);
<ide> b[len] = rs;
<del> if (subscribers.compareAndSet(a, b)) {
<add> if (observers.compareAndSet(a, b)) {
<ide> return true;
<ide> }
<ide> }
<ide> boolean add(BehaviorDisposable<T> rs) {
<ide> @SuppressWarnings("unchecked")
<ide> void remove(BehaviorDisposable<T> rs) {
<ide> for (;;) {
<del> BehaviorDisposable<T>[] a = subscribers.get();
<add> BehaviorDisposable<T>[] a = observers.get();
<ide> int len = a.length;
<ide> if (len == 0) {
<ide> return;
<ide> void remove(BehaviorDisposable<T> rs) {
<ide> System.arraycopy(a, 0, b, 0, j);
<ide> System.arraycopy(a, j + 1, b, j, len - j - 1);
<ide> }
<del> if (subscribers.compareAndSet(a, b)) {
<add> if (observers.compareAndSet(a, b)) {
<ide> return;
<ide> }
<ide> }
<ide> void remove(BehaviorDisposable<T> rs) {
<ide> @SuppressWarnings("unchecked")
<ide> BehaviorDisposable<T>[] terminate(Object terminalValue) {
<ide>
<del> BehaviorDisposable<T>[] a = subscribers.getAndSet(TERMINATED);
<del> if (a != TERMINATED) {
<del> // either this or atomics with lots of allocation
<del> setCurrent(terminalValue);
<del> }
<add> setCurrent(terminalValue);
<ide>
<del> return a;
<add> return observers.getAndSet(TERMINATED);
<ide> }
<ide>
<ide> void setCurrent(Object o) {
<ide><path>src/main/java/io/reactivex/rxjava3/subjects/ReplaySubject.java
<ide> protected void subscribeActual(Observer<? super T> observer) {
<ide> ReplayDisposable<T> rs = new ReplayDisposable<>(observer, this);
<ide> observer.onSubscribe(rs);
<ide>
<del> if (!rs.cancelled) {
<del> if (add(rs)) {
<del> if (rs.cancelled) {
<del> remove(rs);
<del> return;
<del> }
<add> if (add(rs)) {
<add> if (rs.cancelled) {
<add> remove(rs);
<add> return;
<ide> }
<del> buffer.replay(rs);
<ide> }
<add> buffer.replay(rs);
<ide> }
<ide>
<ide> @Override
<ide> void remove(ReplayDisposable<T> rs) {
<ide>
<ide> @SuppressWarnings("unchecked")
<ide> ReplayDisposable<T>[] terminate(Object terminalValue) {
<del> if (buffer.compareAndSet(null, terminalValue)) {
<del> return observers.getAndSet(TERMINATED);
<del> }
<del> return TERMINATED;
<add> buffer.compareAndSet(null, terminalValue);
<add> return observers.getAndSet(TERMINATED);
<ide> }
<ide>
<ide> /**
<ide> void trim() {
<ide> break;
<ide> }
<ide> TimedNode<Object> next = h.get();
<del> if (next == null) {
<del> head = h;
<del> break;
<del> }
<ide>
<ide> if (next.time > limit) {
<ide> head = h;
<ide> public void replay(ReplayDisposable<T> rs) {
<ide>
<ide> for (;;) {
<ide>
<del> if (rs.cancelled) {
<del> rs.index = null;
<del> return;
<del> }
<del>
<ide> for (;;) {
<ide> if (rs.cancelled) {
<ide> rs.index = null;
<ide> public void replay(ReplayDisposable<T> rs) {
<ide> index = n;
<ide> }
<ide>
<del> if (index.get() != null) {
<del> continue;
<del> }
<del>
<ide> rs.index = index;
<ide>
<ide> missed = rs.addAndGet(-missed);
<ide><path>src/main/java/io/reactivex/rxjava3/subscribers/TestSubscriber.java
<ide> public void onError(@NonNull Throwable t) {
<ide> if (!checkSubscriptionOnce) {
<ide> checkSubscriptionOnce = true;
<ide> if (upstream.get() == null) {
<del> errors.add(new NullPointerException("onSubscribe not called in proper order"));
<add> errors.add(new IllegalStateException("onSubscribe not called in proper order"));
<ide> }
<ide> }
<ide> try {
<ide> lastThread = Thread.currentThread();
<del> errors.add(t);
<ide>
<ide> if (t == null) {
<del> errors.add(new IllegalStateException("onError received a null Throwable"));
<add> errors.add(new NullPointerException("onError received a null Throwable"));
<add> } else {
<add> errors.add(t);
<ide> }
<ide>
<ide> downstream.onError(t);
<ide><path>src/test/java/io/reactivex/rxjava3/core/NotificationTest.java
<ide> public void valueOfOnCompleteIsNull() {
<ide> public void notEqualsToObject() {
<ide> Notification<Integer> n1 = Notification.createOnNext(0);
<ide> assertNotEquals(0, n1);
<add> assertNotEquals(n1, 0);
<ide> Notification<Integer> n2 = Notification.createOnError(new TestException());
<ide> assertNotEquals(0, n2);
<add> assertNotEquals(n2, 0);
<ide> Notification<Integer> n3 = Notification.createOnComplete();
<ide> assertNotEquals(0, n3);
<add> assertNotEquals(n3, 0);
<add> }
<add>
<add> @Test
<add> public void twoEqual() {
<add> Notification<Integer> n1 = Notification.createOnNext(0);
<add> Notification<Integer> n2 = Notification.createOnNext(0);
<add> assertEquals(n1, n2);
<add> assertEquals(n2, n1);
<ide> }
<ide>
<ide> @Test
<ide><path>src/test/java/io/reactivex/rxjava3/internal/functions/FunctionsTest.java
<ide> public void utilityClass() {
<ide> public void hashSetCallableEnum() {
<ide> // inlined TestHelper.checkEnum due to access restrictions
<ide> try {
<del> Method m = Functions.HashSetCallable.class.getMethod("values");
<add> Method m = Functions.HashSetSupplier.class.getMethod("values");
<ide> m.setAccessible(true);
<del> Method e = Functions.HashSetCallable.class.getMethod("valueOf", String.class);
<add> Method e = Functions.HashSetSupplier.class.getMethod("valueOf", String.class);
<ide> e.setAccessible(true);
<ide>
<del> for (Enum<HashSetCallable> o : (Enum<HashSetCallable>[])m.invoke(null)) {
<add> for (Enum<HashSetSupplier> o : (Enum<HashSetSupplier>[])m.invoke(null)) {
<ide> assertSame(o, e.invoke(null, o.name()));
<ide> }
<ide>
<ide><path>src/test/java/io/reactivex/rxjava3/internal/fuseable/CancellableQueueFuseableTest.java
<ide> public void offer() {
<ide> TestHelper.assertNoOffer(new CancellableQueueFuseable<>());
<ide> }
<ide>
<add> @Test
<add> public void pollClear() throws Throwable {
<add> CancellableQueueFuseable<Object> qs = new CancellableQueueFuseable<>();
<add>
<add> assertNull(qs.poll());
<add>
<add> qs.clear();
<add> assertNull(qs.poll());
<add> }
<add>
<ide> @Test
<ide> public void cancel() {
<ide> CancellableQueueFuseable<Object> qs = new CancellableQueueFuseable<>();
<ide><path>src/test/java/io/reactivex/rxjava3/internal/observers/DeferredScalarDisposableTest.java
<add>/**
<add> * Copyright (c) 2016-present, RxJava Contributors.
<add> *
<add> * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
<add> * compliance with the License. You may obtain a copy of the License at
<add> *
<add> * http://www.apache.org/licenses/LICENSE-2.0
<add> *
<add> * Unless required by applicable law or agreed to in writing, software distributed under the License is
<add> * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
<add> * the License for the specific language governing permissions and limitations under the License.
<add> */
<add>
<add>package io.reactivex.rxjava3.internal.observers;
<add>
<add>import static org.junit.Assert.*;
<add>
<add>import org.junit.Test;
<add>
<add>import io.reactivex.rxjava3.core.RxJavaTest;
<add>import io.reactivex.rxjava3.observers.TestObserver;
<add>
<add>public class DeferredScalarDisposableTest extends RxJavaTest {
<add>
<add> @Test
<add> public void tryDispose() {
<add> TestObserver<Integer> to = new TestObserver<>();
<add>
<add> DeferredScalarDisposable<Integer> d = new DeferredScalarDisposable<>(to);
<add> to.onSubscribe(d);
<add>
<add> assertTrue(d.tryDispose());
<add> assertFalse(d.tryDispose());
<add> }
<add>}
<ide><path>src/test/java/io/reactivex/rxjava3/internal/observers/FutureMultiObserverTest.java
<add>/**
<add> * Copyright (c) 2016-present, RxJava Contributors.
<add> *
<add> * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
<add> * compliance with the License. You may obtain a copy of the License at
<add> *
<add> * http://www.apache.org/licenses/LICENSE-2.0
<add> *
<add> * Unless required by applicable law or agreed to in writing, software distributed under the License is
<add> * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
<add> * the License for the specific language governing permissions and limitations under the License.
<add> */
<add>
<add>package io.reactivex.rxjava3.internal.observers;
<add>
<add>import static org.junit.Assert.*;
<add>import org.junit.Test;
<add>
<add>import io.reactivex.rxjava3.core.RxJavaTest;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<add>
<add>public class FutureMultiObserverTest extends RxJavaTest {
<add>
<add> @Test
<add> public void cancelBeforeOnSubscribe() {
<add> FutureMultiObserver<Integer> f = new FutureMultiObserver<>();
<add>
<add> assertTrue(f.cancel(true));
<add>
<add> Disposable d = Disposable.empty();
<add>
<add> f.onSubscribe(d);
<add>
<add> assertTrue(d.isDisposed());
<add> }
<add>
<add> @Test
<add> public void onCompleteJustAfterDispose() {
<add> FutureMultiObserver<Integer> f = new FutureMultiObserver<>();
<add> Disposable d = Disposable.empty();
<add> f.onSubscribe(d);
<add> assertTrue(f.cancel(true));
<add>
<add> f.onComplete();
<add> }
<add>}
<ide><path>src/test/java/io/reactivex/rxjava3/internal/observers/FutureObserverTest.java
<ide> import org.junit.*;
<ide>
<ide> import io.reactivex.rxjava3.core.RxJavaTest;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<del>import io.reactivex.rxjava3.internal.subscribers.FutureSubscriber;
<del>import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide> public void onSubscribe() throws Exception {
<ide> @Test
<ide> public void cancelRace() {
<ide> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<del> final FutureSubscriber<Integer> fo = new FutureSubscriber<>();
<add> final FutureObserver<Integer> fo = new FutureObserver<>();
<ide>
<ide> Runnable r = new Runnable() {
<ide> @Override
<ide> public void onErrorCancelRace() {
<ide> RxJavaPlugins.setErrorHandler(Functions.emptyConsumer());
<ide> try {
<ide> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<del> final FutureSubscriber<Integer> fo = new FutureSubscriber<>();
<add> final FutureObserver<Integer> fo = new FutureObserver<>();
<ide>
<ide> final TestException ex = new TestException();
<ide>
<ide> public void onCompleteCancelRace() {
<ide> RxJavaPlugins.setErrorHandler(Functions.emptyConsumer());
<ide> try {
<ide> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<del> final FutureSubscriber<Integer> fo = new FutureSubscriber<>();
<add> final FutureObserver<Integer> fo = new FutureObserver<>();
<ide>
<ide> if (i % 3 == 0) {
<del> fo.onSubscribe(new BooleanSubscription());
<add> fo.onSubscribe(Disposable.empty());
<ide> }
<ide>
<ide> if (i % 2 == 0) {
<ide> public void onCompleteOnError() throws Exception {
<ide> }
<ide> }
<ide>
<add> @Test
<add> public void onNextCompleteOnError() throws Exception {
<add> List<Throwable> errors = TestHelper.trackPluginErrors();
<add> try {
<add> fo.onNext(1);
<add> fo.onComplete();
<add> fo.onError(new TestException("One"));
<add>
<add> assertEquals((Integer)1, fo.get(5, TimeUnit.MILLISECONDS));
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> } finally {
<add> RxJavaPlugins.reset();
<add> }
<add> }
<add>
<ide> @Test
<ide> public void cancelOnError() throws Exception {
<ide> List<Throwable> errors = TestHelper.trackPluginErrors();
<ide> public void getTimedOut() throws Exception {
<ide> assertEquals(timeoutMessage(1, TimeUnit.NANOSECONDS), expected.getMessage());
<ide> }
<ide> }
<add>
<add> @Test
<add> public void cancelOnSubscribeRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> final FutureObserver<Integer> fo = new FutureObserver<>();
<add>
<add> Runnable r = new Runnable() {
<add> @Override
<add> public void run() {
<add> fo.cancel(false);
<add> }
<add> };
<add>
<add> Disposable d = Disposable.empty();
<add>
<add> TestHelper.race(r, () -> fo.onSubscribe(d));
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/observers/InnerQueuedObserverTest.java
<add>/**
<add> * Copyright (c) 2016-present, RxJava Contributors.
<add> *
<add> * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
<add> * compliance with the License. You may obtain a copy of the License at
<add> *
<add> * http://www.apache.org/licenses/LICENSE-2.0
<add> *
<add> * Unless required by applicable law or agreed to in writing, software distributed under the License is
<add> * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
<add> * the License for the specific language governing permissions and limitations under the License.
<add> */
<add>
<add>package io.reactivex.rxjava3.internal.observers;
<add>
<add>import org.junit.Test;
<add>
<add>import io.reactivex.rxjava3.core.RxJavaTest;
<add>import io.reactivex.rxjava3.testsupport.TestHelper;
<add>
<add>public class InnerQueuedObserverTest extends RxJavaTest {
<add>
<add> @Test
<add> public void dispose() {
<add> TestHelper.checkDisposed(new InnerQueuedObserver<>(null, 1));
<add> }
<add>}
<add><path>src/test/java/io/reactivex/rxjava3/internal/operators/completable/CompletableAndThenCompletableTest.java
<del><path>src/test/java/io/reactivex/rxjava3/internal/operators/completable/CompletableAndThenCompletableabTest.java
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<del>public class CompletableAndThenCompletableabTest extends RxJavaTest {
<add>public class CompletableAndThenCompletableTest extends RxJavaTest {
<ide> @Test
<ide> public void andThenCompletableCompleteComplete() {
<ide> Completable.complete()
<ide> public void run() throws Exception {
<ide> assertFalse("The second Completable was interrupted!", interrupted[0]);
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeCompletable(c -> c.andThen(c));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/completable/CompletableConcatTest.java
<ide> public void run() throws Exception {
<ide> assertFalse("The second Completable was interrupted!", interrupted[0]);
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.<Completable>checkDoubleOnSubscribeFlowableToCompletable(f -> Completable.concat(f));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/completable/CompletableDisposeOnTest.java
<ide> import io.reactivex.rxjava3.functions.Action;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<del>import io.reactivex.rxjava3.schedulers.TestScheduler;
<add>import io.reactivex.rxjava3.schedulers.*;
<ide> import io.reactivex.rxjava3.subjects.PublishSubject;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public void run() throws Exception {
<ide>
<ide> assertEquals(0, call[0]);
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeCompletable(c -> c.unsubscribeOn(Schedulers.computation()));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/completable/CompletableFromActionTest.java
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.Action;
<add>import io.reactivex.rxjava3.observers.TestObserver;
<add>import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public class CompletableFromActionTest extends RxJavaTest {
<ide> @Test
<ide> public void disposedUpfront() throws Throwable {
<ide>
<ide> verify(run, never()).run();
<ide> }
<add>
<add> @Test
<add> public void disposeWhileRunningComplete() {
<add> TestObserver<Void> to = new TestObserver<>();
<add>
<add> Completable.fromAction(() -> {
<add> to.dispose();
<add> })
<add> .subscribeWith(to)
<add> .assertEmpty();
<add> }
<add>
<add> @Test
<add> public void disposeWhileRunningError() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> TestObserver<Void> to = new TestObserver<>();
<add>
<add> Completable.fromAction(() -> {
<add> to.dispose();
<add> throw new TestException();
<add> })
<add> .subscribeWith(to)
<add> .assertEmpty();
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> });
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/completable/CompletableFromRunnableTest.java
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<add>import io.reactivex.rxjava3.observers.TestObserver;
<add>import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public class CompletableFromRunnableTest extends RxJavaTest {
<ide> @Test
<ide> public void disposedUpfront() throws Throwable {
<ide>
<ide> verify(run, never()).run();
<ide> }
<add>
<add> @Test
<add> public void disposeWhileRunningComplete() {
<add> TestObserver<Void> to = new TestObserver<>();
<add>
<add> Completable.fromRunnable(() -> {
<add> to.dispose();
<add> })
<add> .subscribeWith(to)
<add> .assertEmpty();
<add> }
<add>
<add> @Test
<add> public void disposeWhileRunningError() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> TestObserver<Void> to = new TestObserver<>();
<add>
<add> Completable.fromRunnable(() -> {
<add> to.dispose();
<add> throw new TestException();
<add> })
<add> .subscribeWith(to)
<add> .assertEmpty();
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> });
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/completable/CompletableMergeIterableTest.java
<ide> package io.reactivex.rxjava3.internal.operators.completable;
<ide>
<ide> import java.util.*;
<add>import java.util.concurrent.atomic.AtomicInteger;
<ide>
<ide> import org.junit.Test;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<add>import io.reactivex.rxjava3.disposables.CompositeDisposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<add>import io.reactivex.rxjava3.internal.operators.completable.CompletableMergeIterable.MergeCompletableObserver;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.subjects.PublishSubject;
<ide> public void remove() {
<ide>
<ide> to.assertEmpty();
<ide> }
<add>
<add> @Test
<add> public void dispose() {
<add> TestHelper.checkDisposed(new MergeCompletableObserver(new TestObserver<Void>(), new CompositeDisposable(), new AtomicInteger()));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/completable/CompletableMergeTest.java
<ide> import static org.junit.Assert.*;
<ide>
<ide> import java.util.*;
<add>import java.util.concurrent.atomic.AtomicBoolean;
<ide>
<ide> import org.junit.Test;
<ide> import org.reactivestreams.Subscriber;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.Function;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<add>import io.reactivex.rxjava3.internal.util.AtomicThrowable;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.PublishProcessor;
<add>import io.reactivex.rxjava3.subjects.CompletableSubject;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public class CompletableMergeTest extends RxJavaTest {
<ide> public Completable apply(Flowable<Integer> upstream) {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void iterableCompleteLater() {
<add> CompletableSubject cs = CompletableSubject.create();
<add>
<add> TestObserver<Void> to = Completable.mergeDelayError(Arrays.asList(cs, cs, cs))
<add> .test();
<add>
<add> to.assertEmpty();
<add>
<add> cs.onComplete();
<add>
<add> to.assertResult();
<add> }
<add>
<add> @Test
<add> public void terminalDisposed() {
<add> TestHelper.checkDisposed(new CompletableMergeArrayDelayError.TryTerminateAndReportDisposable(new AtomicThrowable()));
<add> }
<add>
<add> @Test
<add> public void innerDisposed() {
<add> TestHelper.checkDisposed(new CompletableMergeArray.InnerCompletableObserver(new TestObserver<Void>(), new AtomicBoolean(), new CompositeDisposable(), 1));
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.<Completable>checkDoubleOnSubscribeFlowableToCompletable(f -> Completable.merge(f));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableAmbTest.java
<ide> import org.mockito.InOrder;
<ide> import org.reactivestreams.*;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.disposables.CompositeDisposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> public void subscribe(Subscriber<? super Integer> subscriber) {
<ide> .test()
<ide> .assertResult(1);
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.amb(Arrays.asList(Flowable.never(), Flowable.never())));
<add> }
<add>
<add> @Test
<add> public void requestAfterCancel() {
<add> Flowable.amb(Arrays.asList(Flowable.never(), Flowable.never()))
<add> .subscribe(new FlowableSubscriber<Object>() {
<add>
<add> @Override
<add> public void onNext(@NonNull Object t) {
<add> }
<add>
<add> @Override
<add> public void onError(Throwable t) {
<add> }
<add>
<add> @Override
<add> public void onComplete() {
<add> }
<add>
<add> @Override
<add> public void onSubscribe(@NonNull Subscription s) {
<add> s.cancel();
<add> s.request(1);
<add> }
<add> });
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableBufferTest.java
<ide> import io.reactivex.rxjava3.internal.operators.flowable.FlowableBufferTimed.*;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<del>import io.reactivex.rxjava3.processors.PublishProcessor;
<add>import io.reactivex.rxjava3.processors.*;
<ide> import io.reactivex.rxjava3.schedulers.*;
<ide> import io.reactivex.rxjava3.subscribers.*;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide> public List<Object> get() throws Exception {
<ide> .assertFailure(TestException.class)
<ide> ;
<ide> }
<add>
<add> @Test
<add> public void exactBadRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().buffer(1));
<add> }
<add>
<add> @Test
<add> public void skipBadRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().buffer(1, 2));
<add> }
<add>
<add> @Test
<add> public void overlapBadRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().buffer(2, 1));
<add> }
<add>
<add> @Test
<add> public void bufferExactBoundedOnNextAfterDispose() {
<add> TestSubscriber<Object> ts = new TestSubscriber<>();
<add>
<add> Flowable.unsafeCreate(s -> {
<add> s.onSubscribe(new BooleanSubscription());
<add> ts.cancel();
<add> s.onNext(1);
<add> })
<add> .buffer(1, TimeUnit.MINUTES, 2)
<add> .subscribe(ts);
<add>
<add> ts.assertEmpty();
<add> }
<add>
<add> @Test
<add> public void boundaryCloseCompleteRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> BehaviorProcessor<Integer> bp = BehaviorProcessor.createDefault(1);
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<List<Integer>> ts = bp
<add> .buffer(BehaviorProcessor.createDefault(0), v -> pp)
<add> .test();
<add>
<add> TestHelper.race(
<add> () -> bp.onComplete(),
<add> () -> pp.onComplete()
<add> );
<add>
<add> ts.assertResult(Arrays.asList(1));
<add> }
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribeStartEnd() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> f.buffer(Flowable.never(), v -> Flowable.never()));
<add> }
<add>
<add> @Test
<add> public void cancel() {
<add> TestHelper.checkDisposed(Flowable.never().buffer(Flowable.never(), v -> Flowable.never()));
<add> }
<add>
<add> @Test
<add> public void startEndCancelAfterOneBuffer() {
<add> BehaviorProcessor.createDefault(1)
<add> .buffer(BehaviorProcessor.createDefault(2), v -> Flowable.just(1))
<add> .takeUntil(v -> true)
<add> .test()
<add> .assertResult(Arrays.asList());
<add> }
<add>
<add> @Test
<add> public void startEndCompleteOnBoundary() {
<add> Flowable.empty()
<add> .buffer(Flowable.never(), v -> Flowable.just(1))
<add> .take(1)
<add> .test()
<add> .assertResult();
<add> }
<add>
<add> @Test
<add> public void startEndBackpressure() {
<add> BehaviorProcessor.createDefault(1)
<add> .buffer(BehaviorProcessor.createDefault(2), v -> Flowable.just(1))
<add> .test(1L)
<add> .assertValuesOnly(Arrays.asList());
<add> }
<add>
<add> @Test
<add> public void startEndBackpressureMoreWork() {
<add> PublishProcessor<Integer> bp = PublishProcessor.create();
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add> AtomicInteger counter = new AtomicInteger();
<add>
<add> TestSubscriber<List<Integer>> ts = bp
<add> .buffer(pp, v -> Flowable.just(1))
<add> .doOnNext(v -> {
<add> if (counter.getAndIncrement() == 0) {
<add> pp.onNext(2);
<add> pp.onComplete();
<add> }
<add> })
<add> .test(1L);
<add>
<add> pp.onNext(1);
<add> bp.onNext(1);
<add>
<add> ts
<add> .assertValuesOnly(Arrays.asList());
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableCacheTest.java
<ide> public void backpressure() {
<ide> .requestMore(3)
<ide> .assertResult(1, 2, 3, 4, 5);
<ide> }
<add>
<add> @Test
<add> public void addRemoveRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> Flowable<Object> f = Flowable.never().cache();
<add>
<add> TestSubscriber<Object> ts = f.test();
<add>
<add> TestHelper.race(
<add> () -> ts.cancel(),
<add> () -> f.test()
<add> );
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableCombineLatestTest.java
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.fuseable.QueueFuseable;
<ide> import io.reactivex.rxjava3.internal.operators.flowable.FlowableZipTest.ArgsToString;
<add>import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.PublishProcessor;
<ide> import io.reactivex.rxjava3.schedulers.*;
<ide> public Object apply(Object[] a) throws Exception {
<ide> public void combine2Flowable2Errors() throws Exception {
<ide> List<Throwable> errors = TestHelper.trackPluginErrors();
<ide> try {
<del> TestSubscriber<Object> testObserver = TestSubscriber.create();
<add> TestSubscriber<Object> testSubscriber = TestSubscriber.create();
<ide>
<ide> TestScheduler testScheduler = new TestScheduler();
<ide>
<ide> public void run() throws Exception {
<ide> System.out.println("combineLatestDelayError: doFinally");
<ide> }
<ide> })
<del> .subscribe(testObserver);
<add> .subscribe(testSubscriber);
<ide>
<ide> testScheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
<ide>
<del> testObserver.awaitDone(5, TimeUnit.SECONDS);
<add> testSubscriber.awaitDone(5, TimeUnit.SECONDS);
<ide>
<ide> assertTrue(errors.toString(), errors.isEmpty());
<ide> } finally {
<ide> public Integer apply(Object[] t) throws Throwable {
<ide> .test()
<ide> .assertResult(2);
<ide> }
<add>
<add> @Test
<add> public void FlowableSourcesInIterable() {
<add> Flowable<Integer> source = new Flowable<Integer>() {
<add> @Override
<add> public void subscribeActual(Subscriber<? super Integer> s) {
<add> Flowable.just(1).subscribe(s);
<add> }
<add> };
<add>
<add> Flowable.combineLatest(Arrays.asList(source, source), new Function<Object[], Integer>() {
<add> @Override
<add> public Integer apply(Object[] t) throws Throwable {
<add> return 2;
<add> }
<add> })
<add> .test()
<add> .assertResult(2);
<add> }
<add>
<add> @Test
<add> public void onCompleteDisposeRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> Flowable.combineLatest(pp, Flowable.never(), (a, b) -> a)
<add> .subscribe(ts);
<add>
<add> TestHelper.race(() -> pp.onComplete(), () -> ts.cancel());
<add> }
<add> }
<add>
<add> @Test
<add> public void onErrorDisposeDelayErrorRace() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> TestException ex = new TestException();
<add>
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add>
<add> TestSubscriberEx<Object[]> ts = new TestSubscriberEx<>();
<add> AtomicReference<Subscriber<? super Object>> ref = new AtomicReference<>();
<add> Flowable<Object> f = new Flowable<Object>() {
<add> @Override
<add> public void subscribeActual(Subscriber<? super Object> s) {
<add> ref.set(s);
<add> }
<add> };
<add>
<add> Flowable.combineLatestDelayError(Arrays.asList(f, Flowable.never()), (a) -> a)
<add> .subscribe(ts);
<add>
<add> ref.get().onSubscribe(new BooleanSubscription());
<add>
<add> TestHelper.race(() -> ref.get().onError(ex), () -> ts.cancel());
<add>
<add> if (ts.errors().isEmpty()) {
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> }
<add> }
<add> });
<add> }
<add>
<add> @Test
<add> public void doneButNotEmpty() {
<add> PublishProcessor<Integer> pp1 = PublishProcessor.create();
<add> PublishProcessor<Integer> pp2 = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = Flowable.combineLatest(pp1, pp2, (a, b) -> a + b)
<add> .doOnNext(v -> {
<add> if (v == 2) {
<add> pp2.onNext(3);
<add> pp2.onComplete();
<add> pp1.onComplete();
<add> }
<add> })
<add> .test();
<add>
<add> pp1.onNext(1);
<add> pp2.onNext(1);
<add>
<add> ts.assertResult(2, 4);
<add> }
<add>
<add> @Test
<add> public void iterableNullPublisher() {
<add> Flowable.combineLatest(Arrays.asList(Flowable.never(), null), (a) -> a)
<add> .test()
<add> .assertFailure(NullPointerException.class);
<add> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.combineLatest(Flowable.never(), Flowable.never(), (a, b) -> a));
<add> }
<add>
<add> @Test
<add> public void syncFusionRejected() {
<add> TestSubscriberEx<Object> ts = new TestSubscriberEx<>();
<add> ts.setInitialFusionMode(QueueFuseable.SYNC);
<add>
<add> Flowable.combineLatest(Flowable.never(), Flowable.never(), (a, b) -> a)
<add> .subscribe(ts);
<add>
<add> ts.assertFuseable()
<add> .assertFusionMode(QueueFuseable.NONE);
<add> }
<add>
<add> @Test
<add> public void bounderyFusionRejected() {
<add> TestSubscriberEx<Object> ts = new TestSubscriberEx<>();
<add> ts.setInitialFusionMode(QueueFuseable.ANY | QueueFuseable.BOUNDARY);
<add>
<add> Flowable.combineLatest(Flowable.never(), Flowable.never(), (a, b) -> a)
<add> .subscribe(ts);
<add>
<add> ts.assertFuseable()
<add> .assertFusionMode(QueueFuseable.NONE);
<add> }
<add>
<add> @Test
<add> public void fusedNormal() {
<add> TestSubscriberEx<Integer> ts = new TestSubscriberEx<>();
<add> ts.setInitialFusionMode(QueueFuseable.ANY);
<add>
<add> Flowable.combineLatest(Flowable.just(1), Flowable.just(2), (a, b) -> a + b)
<add> .subscribeWith(ts)
<add> .assertFuseable()
<add> .assertFusionMode(QueueFuseable.ASYNC)
<add> .assertResult(3);
<add> }
<add>
<add> @Test
<add> public void fusedToParallel() {
<add> TestSubscriberEx<Integer> ts = new TestSubscriberEx<>();
<add> ts.setInitialFusionMode(QueueFuseable.ANY);
<add>
<add> Flowable.combineLatest(Flowable.just(1), Flowable.just(2), (a, b) -> a + b)
<add> .parallel()
<add> .sequential()
<add> .subscribeWith(ts)
<add> .assertResult(3);
<add> }
<add>
<add> @Test
<add> public void fusedToParallel2() {
<add> TestSubscriberEx<Integer> ts = new TestSubscriberEx<>();
<add> ts.setInitialFusionMode(QueueFuseable.ANY);
<add>
<add> Flowable.combineLatest(Flowable.just(1), Flowable.just(2), (a, b) -> a + b)
<add> .compose(TestHelper.flowableStripBoundary())
<add> .parallel()
<add> .sequential()
<add> .subscribeWith(ts)
<add> .assertResult(3);
<add> }
<add>
<add> @Test
<add> public void fusedError() {
<add> TestSubscriberEx<Integer> ts = new TestSubscriberEx<>();
<add> ts.setInitialFusionMode(QueueFuseable.ANY);
<add>
<add> Flowable.combineLatest(Flowable.just(1), Flowable.<Integer>error(new TestException()), (a, b) -> a + b)
<add> .subscribeWith(ts)
<add> .assertFuseable()
<add> .assertFusionMode(QueueFuseable.ASYNC)
<add> .assertFailure(TestException.class);
<add> }
<add>
<add> @Test
<add> public void nonFusedMoreWorkBeforeTermination() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = Flowable.combineLatest(pp, Flowable.just(1), (a, b) -> a + b)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onNext(2);
<add> pp.onComplete();
<add> }
<add> })
<add> .test();
<add>
<add> pp.onNext(0);
<add>
<add> ts.assertResult(1, 3);
<add> }
<add>
<add> @Test
<add> public void nonFusedDelayErrorMoreWorkBeforeTermination() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<List<Object>> ts = Flowable.combineLatestDelayError(Arrays.asList(pp, Flowable.just(1)), a -> Arrays.asList(a))
<add> .doOnNext(v -> {
<add> if (((Integer)v.get(0)) == 0) {
<add> pp.onNext(2);
<add> pp.onComplete();
<add> }
<add> })
<add> .test();
<add>
<add> pp.onNext(0);
<add>
<add> ts.assertResult(Arrays.asList(0, 1), Arrays.asList(2, 1));
<add> }
<add>
<add> @Test
<add> public void fusedCombinerCrashError() {
<add> TestSubscriberEx<Object> ts = new TestSubscriberEx<>();
<add> ts.setInitialFusionMode(QueueFuseable.ANY);
<add>
<add> Flowable.combineLatest(Flowable.just(1), Flowable.just(1), (a, b) -> { throw new TestException(); })
<add> .subscribeWith(ts)
<add> .assertFuseable()
<add> .assertFusionMode(QueueFuseable.ASYNC)
<add> .assertFailure(TestException.class);
<add> }
<add>
<add> @Test
<add> public void fusedCombinerCrashError2() {
<add> Flowable.combineLatest(Flowable.just(1), Flowable.just(1), (a, b) -> { throw new TestException(); })
<add> .compose(TestHelper.flowableStripBoundary())
<add> .rebatchRequests(10)
<add> .test()
<add> .assertFailure(TestException.class);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableConcatMapEagerTest.java
<ide> public void publisherDelayErrorMaxConcurrency() {
<ide> .test()
<ide> .assertFailure(TestException.class, 1, 2, 3, 4, 5);
<ide> }
<add>
<add> @Test
<add> public void innerSyncFused() {
<add> Flowable.just(1)
<add> .hide()
<add> .concatMapEagerDelayError(v -> Flowable.range(1, 10), true, 1, 1)
<add> .test()
<add> .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
<add> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().concatMapEagerDelayError(v -> Flowable.never(), false));
<add> }
<add>
<add> @Test
<add> public void cancelAfterOnNext() {
<add> Flowable.just(1)
<add> .hide()
<add> .concatMapEagerDelayError(v -> Flowable.range(1, 5).hide(), true)
<add> .takeUntil(v -> true)
<add> .test()
<add> .assertResult(1);
<add> }
<add>
<add> @Test
<add> public void noInnerQueue() {
<add> Flowable.just(1)
<add> .hide()
<add> .concatMapEagerDelayError(v -> Flowable.fromPublisher(s -> { }), true)
<add> .test(0L)
<add> .assertEmpty()
<add> .requestMore(1L)
<add> .assertEmpty()
<add> ;
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableConcatMapSchedulerTest.java
<ide> import java.lang.reflect.Method;
<ide> import java.util.*;
<ide> import java.util.concurrent.*;
<del>import java.util.concurrent.atomic.AtomicInteger;
<add>import java.util.concurrent.atomic.*;
<ide>
<ide> import org.junit.Test;
<ide> import org.reactivestreams.*;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.schedulers.ImmediateThinScheduler;
<del>import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<add>import io.reactivex.rxjava3.internal.subscriptions.*;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.*;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> public Publisher<Integer> apply(Integer v) throws Throwable {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void fusionRejected() {
<add> TestSubscriberEx<Object> ts = new TestSubscriberEx<>();
<add>
<add> TestHelper.rejectFlowableFusion()
<add> .concatMap(v -> Flowable.never(), 2, ImmediateThinScheduler.INSTANCE)
<add> .subscribe(ts);
<add> }
<add>
<add> @Test
<add> public void fusionRejectedDelayErrorr() {
<add> TestSubscriberEx<Object> ts = new TestSubscriberEx<>();
<add>
<add> TestHelper.rejectFlowableFusion()
<add> .concatMapDelayError(v -> Flowable.never(), true, 2, ImmediateThinScheduler.INSTANCE)
<add> .subscribe(ts);
<add> }
<add>
<add> @Test
<add> public void scalarInnerJustDispose() {
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> Flowable.just(1)
<add> .hide()
<add> .concatMap(v -> Flowable.fromCallable(() -> {
<add> ts.cancel();
<add> return 1;
<add> }), 2, ImmediateThinScheduler.INSTANCE)
<add> .subscribe(ts);
<add>
<add> ts.assertEmpty();
<add> }
<add>
<add> @Test
<add> public void scalarInnerJustDisposeDelayError() {
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> Flowable.just(1)
<add> .hide()
<add> .concatMapDelayError(v -> Flowable.fromCallable(() -> {
<add> ts.cancel();
<add> return 1;
<add> }), true, 2, ImmediateThinScheduler.INSTANCE)
<add> .subscribe(ts);
<add>
<add> ts.assertEmpty();
<add> }
<add>
<add> static final class EmptyDisposingFlowable extends Flowable<Object>
<add> implements Supplier<Object> {
<add> final TestSubscriber<Object> ts;
<add> EmptyDisposingFlowable(TestSubscriber<Object> ts) {
<add> this.ts = ts;
<add> }
<add>
<add> @Override
<add> protected void subscribeActual(@NonNull Subscriber<? super @NonNull Object> subscriber) {
<add> EmptySubscription.complete(subscriber);
<add> }
<add>
<add> @Override
<add> public @NonNull Object get() throws Throwable {
<add> ts.cancel();
<add> return null;
<add> }
<add> }
<add>
<add> @Test
<add> public void scalarInnerEmptyDisposeDelayError() {
<add> TestSubscriber<Object> ts = new TestSubscriber<>();
<add>
<add> Flowable.just(1)
<add> .hide()
<add> .concatMapDelayError(v -> new EmptyDisposingFlowable(ts),
<add> true, 2, ImmediateThinScheduler.INSTANCE
<add> )
<add> .subscribe(ts);
<add>
<add> ts.assertEmpty();
<add> }
<add>
<add> @Test
<add> public void mainErrorInnerNextIgnoreCancel() {
<add> AtomicReference<Subscriber<? super Integer>> ref = new AtomicReference<>();
<add>
<add> Flowable.just(1).concatWith(Flowable.<Integer>error(new TestException()))
<add> .concatMap(v -> Flowable.<Integer>fromPublisher(ref::set), 2, ImmediateThinScheduler.INSTANCE)
<add> .doOnError(e -> {
<add> ref.get().onSubscribe(new BooleanSubscription());
<add> ref.get().onNext(1);
<add> })
<add> .test()
<add> .assertFailure(TestException.class);
<add> }
<add>
<add> @Test
<add> public void scalarSupplierMainError() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = pp.concatMap(v -> Flowable.fromCallable(() -> {
<add> pp.onError(new TestException());
<add> return 2;
<add> }), 2, ImmediateThinScheduler.INSTANCE)
<add> .test()
<add> ;
<add>
<add> pp.onNext(1);
<add>
<add> ts.assertFailure(TestException.class);
<add> }
<add>
<add> @Test
<add> public void mainErrorInnerErrorRace() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> TestException ex1 = new TestException();
<add> TestException ex2 = new TestException();
<add>
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> AtomicReference<Subscriber<? super Integer>> ref1 = new AtomicReference<>();
<add> AtomicReference<Subscriber<? super Integer>> ref2 = new AtomicReference<>();
<add>
<add> TestSubscriber<Integer> ts = Flowable.<Integer>fromPublisher(ref1::set)
<add> .concatMap(v -> Flowable.<Integer>fromPublisher(ref2::set), 2, ImmediateThinScheduler.INSTANCE)
<add> .test();
<add>
<add> ref1.get().onSubscribe(new BooleanSubscription());
<add> ref1.get().onNext(1);
<add> ref2.get().onSubscribe(new BooleanSubscription());
<add>
<add> TestHelper.race(() -> ref1.get().onError(ex1), () -> ref2.get().onError(ex2));
<add>
<add> ts.assertError(RuntimeException.class);
<add> errors.clear();
<add> }
<add> });
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableConcatMapTest.java
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.operators.flowable.FlowableConcatMap.WeakScalarSubscription;
<add>import io.reactivex.rxjava3.processors.UnicastProcessor;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide> public Publisher<Integer> apply(Integer v) throws Throwable {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void asyncFusedSource() {
<add> UnicastProcessor<Integer> up = UnicastProcessor.create();
<add> up.onNext(1);
<add> up.onComplete();
<add>
<add> up.concatMap(v -> Flowable.just(1).hide())
<add> .test()
<add> .assertResult(1);
<add> }
<add>
<add> @Test
<add> public void scalarCallableSource() {
<add> Flowable.fromCallable(() -> 1)
<add> .concatMap(v -> Flowable.just(1))
<add> .test()
<add> .assertResult(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableConcatTest.java
<ide> import static org.mockito.ArgumentMatchers.*;
<ide> import static org.mockito.Mockito.*;
<ide>
<add>import java.io.IOException;
<ide> import java.lang.reflect.Method;
<ide> import java.util.*;
<ide> import java.util.concurrent.*;
<ide> import org.reactivestreams.*;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> public void run() throws Exception {
<ide>
<ide> assertEquals(0, counter.get());
<ide> }
<add>
<add> @Test
<add> public void arrayDelayErrorMultipleErrors() {
<add> TestSubscriberEx<Object> ts = new TestSubscriberEx<>();
<add>
<add> Flowable.concatArrayDelayError(Flowable.error(new IOException()), Flowable.error(new TestException()))
<add> .subscribe(ts);
<add>
<add> ts.assertFailure(CompositeException.class);
<add>
<add> TestHelper.assertCompositeExceptions(ts, IOException.class, TestException.class);
<add> }
<add>
<add> @Test
<add> public void arrayDelayErrorMultipleNullErrors() {
<add> TestSubscriberEx<Object> ts = new TestSubscriberEx<>();
<add>
<add> Flowable.concatArrayDelayError(null, null)
<add> .subscribe(ts);
<add>
<add> ts.assertFailure(CompositeException.class);
<add>
<add> TestHelper.assertCompositeExceptions(ts, NullPointerException.class, NullPointerException.class);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableCreateTest.java
<ide>
<ide> import java.io.IOException;
<ide> import java.util.*;
<add>import java.util.concurrent.atomic.AtomicReference;
<ide>
<ide> import org.junit.Test;
<ide> import org.reactivestreams.*;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.Cancellable;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<add>import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public class FlowableCreateTest extends RxJavaTest {
<ide> public void subscribe(FlowableEmitter<Object> emitter) throws Exception {
<ide> }, entry.getKey()).test().assertEmpty();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void serializedMissingMoreWorkWithComplete() {
<add> AtomicReference<FlowableEmitter<Integer>> ref = new AtomicReference<>();
<add>
<add> Flowable.<Integer>create(emitter -> {
<add> emitter = emitter.serialize();
<add> ref.set(emitter);
<add> assertEquals(Long.MAX_VALUE, emitter.requested());
<add> emitter.onNext(1);
<add> }, BackpressureStrategy.MISSING)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> ref.get().onNext(2);
<add> ref.get().onComplete();
<add> }
<add> })
<add> .test()
<add> .assertResult(1, 2);
<add> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.create(e -> { }, BackpressureStrategy.BUFFER));
<add> }
<add>
<add> @Test
<add> public void tryOnErrorNull() {
<add> Flowable.create(emitter -> emitter.tryOnError(null), BackpressureStrategy.MISSING)
<add> .test()
<add> .assertFailure(NullPointerException.class);
<add> }
<add>
<add> @Test
<add> public void serializedCompleteOnNext() {
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> Flowable.<Integer>create(emitter -> {
<add> emitter = emitter.serialize();
<add>
<add> emitter.onComplete();
<add> emitter.onNext(1);
<add> }, BackpressureStrategy.MISSING)
<add> .subscribe(ts);
<add>
<add> ts.assertResult();
<add> }
<add>
<add> @Test
<add> public void serializedCancelOnNext() {
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> Flowable.<Integer>create(emitter -> {
<add> emitter = emitter.serialize();
<add>
<add> ts.cancel();
<add> emitter.onNext(1);
<add> }, BackpressureStrategy.MISSING)
<add> .subscribe(ts);
<add>
<add> ts.assertEmpty();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableDelaySubscriptionOtherTest.java
<ide> public void subscribe(FlowableEmitter<Boolean> emitter) throws Exception {
<ide> exec.shutdown();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribeMain() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> f.delaySubscription(Flowable.empty()));
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribeOther() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> PublishProcessor.create().delaySubscription(f));
<add> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(PublishProcessor.create().delaySubscription(Flowable.empty()));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableDematerializeTest.java
<ide> protected void subscribeActual(Subscriber<? super Notification<Object>> subscrib
<ide> }
<ide>
<ide> @Test
<del> public void nonNotificationInstanceAfterDispose() {
<add> public void notificationInstanceAfterDispose() {
<ide> new Flowable<Notification<Object>>() {
<ide> @Override
<ide> protected void subscribeActual(Subscriber<? super Notification<Object>> subscriber) {
<ide> protected void subscribeActual(Subscriber<? super Notification<Object>> subscrib
<ide> .test()
<ide> .assertResult();
<ide> }
<add>
<add> @Test
<add> @SuppressWarnings("unchecked")
<add> public void nonNotificationInstanceAfterDispose() {
<add> new Flowable<Object>() {
<add> @Override
<add> protected void subscribeActual(Subscriber<? super Object> subscriber) {
<add> subscriber.onSubscribe(new BooleanSubscription());
<add> subscriber.onNext(Notification.createOnComplete());
<add> subscriber.onNext(1);
<add> }
<add> }
<add> .dematerialize(v -> (Notification<Object>)v)
<add> .test()
<add> .assertResult();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableDoFinallyTest.java
<ide> public void syncFusedConditional() {
<ide>
<ide> Flowable.range(1, 5)
<ide> .doFinally(this)
<del> .filter(Functions.alwaysTrue())
<add> .compose(TestHelper.conditional())
<ide> .subscribe(ts);
<ide>
<ide> ts.assertFusionMode(QueueFuseable.SYNC)
<ide> public void nonFusedConditional() {
<ide>
<ide> Flowable.range(1, 5).hide()
<ide> .doFinally(this)
<del> .filter(Functions.alwaysTrue())
<add> .compose(TestHelper.conditional())
<ide> .subscribe(ts);
<ide>
<ide> ts.assertFusionMode(QueueFuseable.NONE)
<ide> public void syncFusedBoundaryConditional() {
<ide>
<ide> Flowable.range(1, 5)
<ide> .doFinally(this)
<del> .filter(Functions.alwaysTrue())
<add> .compose(TestHelper.conditional())
<ide> .subscribe(ts);
<ide>
<ide> ts.assertFusionMode(QueueFuseable.NONE)
<ide> public void asyncFusedConditional() {
<ide>
<ide> up
<ide> .doFinally(this)
<del> .filter(Functions.alwaysTrue())
<add> .compose(TestHelper.conditional())
<ide> .subscribe(ts);
<ide>
<ide> ts.assertFusionMode(QueueFuseable.ASYNC)
<ide> public void asyncFusedBoundaryConditional() {
<ide>
<ide> up
<ide> .doFinally(this)
<del> .filter(Functions.alwaysTrue())
<add> .compose(TestHelper.conditional())
<ide> .subscribe(ts);
<ide>
<ide> ts.assertFusionMode(QueueFuseable.NONE)
<ide> public void run() throws Exception {
<ide>
<ide> assertEquals(Arrays.asList("onNext", "onComplete", "finally"), list);
<ide> }
<add>
<add> @Test
<add> public void fusionRejected() {
<add> TestSubscriberEx<Object> ts = new TestSubscriberEx<>();
<add> ts.setInitialFusionMode(QueueFuseable.ANY);
<add>
<add> TestHelper.rejectFlowableFusion()
<add> .doFinally(() -> { })
<add> .subscribeWith(ts);
<add>
<add> ts.assertFuseable()
<add> .assertFusionMode(QueueFuseable.NONE);
<add> }
<add>
<add> @Test
<add> public void fusionRejectedConditional() {
<add> TestSubscriberEx<Object> ts = new TestSubscriberEx<>();
<add> ts.setInitialFusionMode(QueueFuseable.ANY);
<add>
<add> TestHelper.rejectFlowableFusion()
<add> .doFinally(() -> { })
<add> .compose(TestHelper.conditional())
<add> .subscribeWith(ts);
<add>
<add> ts.assertFuseable()
<add> .assertFusionMode(QueueFuseable.NONE);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFlatMapCompletableTest.java
<ide> import static org.junit.Assert.*;
<ide>
<ide> import java.util.List;
<del>import java.util.concurrent.TimeUnit;
<add>import java.util.concurrent.*;
<ide>
<ide> import org.junit.Test;
<ide> import org.reactivestreams.Subscription;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.*;
<del>import io.reactivex.rxjava3.functions.Function;
<add>import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.fuseable.*;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> protected void subscribeActual(CompletableObserver observer) {
<ide>
<ide> @Test
<ide> public void delayErrorMaxConcurrency() {
<add> Flowable.range(1, 3)
<add> .flatMapCompletable(new Function<Integer, CompletableSource>() {
<add> @Override
<add> public CompletableSource apply(Integer v) throws Exception {
<add> if (v == 2) {
<add> return Completable.error(new TestException());
<add> }
<add> return Completable.complete();
<add> }
<add> }, true, 1)
<add> .toFlowable()
<add> .test()
<add> .assertFailure(TestException.class);
<add> }
<add>
<add> @Test
<add> public void delayErrorMaxConcurrencyCompletable() {
<ide> Flowable.range(1, 3)
<ide> .flatMapCompletable(new Function<Integer, CompletableSource>() {
<ide> @Override
<ide> public Completable apply(Integer v) throws Throwable {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> f.flatMapCompletable(v -> Completable.never()).toFlowable());
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribeCompletable() {
<add> TestHelper.checkDoubleOnSubscribeFlowableToCompletable(f -> f.flatMapCompletable(v -> Completable.never()));
<add> }
<add>
<add> @Test
<add> public void cancelWhileMapping() throws Throwable {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> PublishProcessor<Integer> pp1 = PublishProcessor.create();
<add>
<add> TestSubscriber<Object> ts = new TestSubscriber<>();
<add> CountDownLatch cdl = new CountDownLatch(1);
<add>
<add> pp1.flatMapCompletable(v -> {
<add> TestHelper.raceOther(() -> {
<add> ts.cancel();
<add> }, cdl);
<add> return Completable.complete();
<add> })
<add> .toFlowable()
<add> .subscribe(ts);
<add>
<add> pp1.onNext(1);
<add>
<add> cdl.await();
<add> }
<add> }
<add>
<add> @Test
<add> public void cancelWhileMappingCompletable() throws Throwable {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> PublishProcessor<Integer> pp1 = PublishProcessor.create();
<add>
<add> TestObserver<Void> to = new TestObserver<>();
<add> CountDownLatch cdl = new CountDownLatch(1);
<add>
<add> pp1.flatMapCompletable(v -> {
<add> TestHelper.raceOther(() -> {
<add> to.dispose();
<add> }, cdl);
<add> return Completable.complete();
<add> })
<add> .subscribe(to);
<add>
<add> pp1.onNext(1);
<add>
<add> cdl.await();
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFlatMapMaybeTest.java
<ide> import org.reactivestreams.Subscriber;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.Function;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.PublishProcessor;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<add>import io.reactivex.rxjava3.subjects.MaybeSubject;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public Maybe<Integer> apply(Integer v) throws Throwable {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().flatMapMaybe(v -> Maybe.never()));
<add> }
<add>
<add> @Test
<add> public void successRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> MaybeSubject<Integer> ss1 = MaybeSubject.create();
<add> MaybeSubject<Integer> ss2 = MaybeSubject.create();
<add>
<add> TestSubscriber<Integer> ts = Flowable.just(ss1, ss2).flatMapMaybe(v -> v)
<add> .test();
<add>
<add> TestHelper.race(
<add> () -> ss1.onSuccess(1),
<add> () -> ss2.onSuccess(1)
<add> );
<add>
<add> ts.assertResult(1, 1);
<add> }
<add> }
<add>
<add> @Test
<add> public void successCompleteRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> MaybeSubject<Integer> ss1 = MaybeSubject.create();
<add> MaybeSubject<Integer> ss2 = MaybeSubject.create();
<add>
<add> TestSubscriber<Integer> ts = Flowable.just(ss1, ss2).flatMapMaybe(v -> v)
<add> .test();
<add>
<add> TestHelper.race(
<add> () -> ss1.onSuccess(1),
<add> () -> ss2.onComplete()
<add> );
<add>
<add> ts.assertResult(1);
<add> }
<add> }
<add>
<add> @Test
<add> public void successShortcut() {
<add> MaybeSubject<Integer> ss1 = MaybeSubject.create();
<add>
<add> TestSubscriber<Integer> ts = Flowable.just(ss1).hide().flatMapMaybe(v -> v)
<add> .test();
<add>
<add> ss1.onSuccess(1);
<add>
<add> ts.assertResult(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFlatMapSingleTest.java
<ide> import org.reactivestreams.Subscriber;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.Function;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.PublishProcessor;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<add>import io.reactivex.rxjava3.subjects.SingleSubject;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public Single<Integer> apply(Integer v) throws Throwable {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().flatMapSingle(v -> Single.never()));
<add> }
<add>
<add> @Test
<add> public void successRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> SingleSubject<Integer> ss1 = SingleSubject.create();
<add> SingleSubject<Integer> ss2 = SingleSubject.create();
<add>
<add> TestSubscriber<Integer> ts = Flowable.just(ss1, ss2).flatMapSingle(v -> v)
<add> .test();
<add>
<add> TestHelper.race(
<add> () -> ss1.onSuccess(1),
<add> () -> ss2.onSuccess(1)
<add> );
<add>
<add> ts.assertResult(1, 1);
<add> }
<add> }
<add>
<add> @Test
<add> public void successShortcut() {
<add> SingleSubject<Integer> ss1 = SingleSubject.create();
<add>
<add> TestSubscriber<Integer> ts = Flowable.just(ss1).hide().flatMapSingle(v -> v)
<add> .test();
<add>
<add> ss1.onSuccess(1);
<add>
<add> ts.assertResult(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFlatMapTest.java
<ide> import static org.mockito.ArgumentMatchers.any;
<ide> import static org.mockito.Mockito.*;
<ide>
<add>import java.io.IOException;
<ide> import java.util.*;
<ide> import java.util.concurrent.*;
<del>import java.util.concurrent.atomic.AtomicInteger;
<add>import java.util.concurrent.atomic.*;
<ide>
<ide> import org.junit.*;
<ide> import org.reactivestreams.*;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<add>import io.reactivex.rxjava3.internal.subscriptions.*;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<del>import io.reactivex.rxjava3.processors.PublishProcessor;
<add>import io.reactivex.rxjava3.processors.*;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide> public void innerErrorsMainCancelled() {
<ide>
<ide> assertFalse("Has subscribers?", pp1.hasSubscribers());
<ide> }
<add>
<add> @Test
<add> public void innerIsDisposed() {
<add> FlowableFlatMap.InnerSubscriber<Integer, Integer> inner = new FlowableFlatMap.InnerSubscriber<>(null, 10, 0L);
<add>
<add> assertFalse(inner.isDisposed());
<add>
<add> inner.dispose();
<add>
<add> assertTrue(inner.isDisposed());
<add> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().flatMap(v -> Flowable.never()));
<add> }
<add>
<add> @Test
<add> public void signalsAfterMapperCrash() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> new Flowable<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull Subscriber<? super @NonNull Integer> s) {
<add> s.onSubscribe(new BooleanSubscription());
<add> s.onNext(1);
<add> s.onNext(2);
<add> s.onComplete();
<add> s.onError(new IOException());
<add> }
<add> }
<add> .flatMap(v -> {
<add> throw new TestException();
<add> })
<add> .test()
<add> .assertFailure(TestException.class);
<add>
<add> TestHelper.assertUndeliverable(errors, 0, IOException.class);
<add> });
<add> }
<add>
<add> @Test
<add> public void scalarQueueTerminate() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> pp
<add> .flatMap(v -> Flowable.just(v))
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onNext(2);
<add> pp.onNext(3);
<add> }
<add> })
<add> .take(2)
<add> .subscribe(ts);
<add>
<add> pp.onNext(1);
<add>
<add> ts.assertResult(1, 2);
<add> }
<add>
<add> @Test
<add> public void scalarQueueCompleteMain() throws Exception {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add> CountDownLatch cdl = new CountDownLatch(1);
<add> pp
<add> .flatMap(v -> Flowable.just(v))
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onNext(2);
<add> TestHelper.raceOther(() -> pp.onComplete(), cdl);
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> pp.onNext(1);
<add>
<add> cdl.await();
<add> ts.assertResult(1, 2);
<add> }
<add>
<add> @Test
<add> public void fusedInnerCrash() {
<add> UnicastProcessor<Integer> up = UnicastProcessor.create();
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = Flowable.just(
<add> pp,
<add> up.map(v -> {
<add> if (v == 10) {
<add> throw new TestException();
<add> }
<add> return v;
<add> })
<add> .compose(TestHelper.flowableStripBoundary())
<add> )
<add> .flatMap(v -> v, true)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onNext(2);
<add> up.onNext(10);
<add> }
<add> })
<add> .test();
<add>
<add> pp.onNext(1);
<add> pp.onComplete();
<add>
<add> ts.assertFailure(TestException.class, 1, 2);
<add> }
<add>
<add> @Test
<add> public void fusedInnerCrash2() {
<add> UnicastProcessor<Integer> up = UnicastProcessor.create();
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = Flowable.just(
<add> up.map(v -> {
<add> if (v == 10) {
<add> throw new TestException();
<add> }
<add> return v;
<add> })
<add> .compose(TestHelper.flowableStripBoundary())
<add> , pp
<add> )
<add> .flatMap(v -> v, true)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onNext(2);
<add> up.onNext(10);
<add> }
<add> })
<add> .test();
<add>
<add> pp.onNext(1);
<add> pp.onComplete();
<add>
<add> ts.assertFailure(TestException.class, 1, 2);
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> f.flatMap(v -> Flowable.never()));
<add> }
<add>
<add> @Test
<add> public void allConcurrency() {
<add> Flowable.just(1)
<add> .hide()
<add> .flatMap(v -> Flowable.just(2).hide(), Integer.MAX_VALUE)
<add> .test()
<add> .assertResult(2);
<add> }
<add>
<add> @Test
<add> public void allConcurrencyScalarInner() {
<add> Flowable.just(1)
<add> .hide()
<add> .flatMap(v -> Flowable.just(2), Integer.MAX_VALUE)
<add> .test()
<add> .assertResult(2);
<add> }
<add>
<add> @Test
<add> public void allConcurrencyScalarInnerEmpty() {
<add> Flowable.just(1)
<add> .hide()
<add> .flatMap(v -> Flowable.empty(), Integer.MAX_VALUE)
<add> .test()
<add> .assertResult();
<add> }
<add>
<add> static final class ScalarEmptyCancel extends Flowable<Integer> implements Supplier<Integer> {
<add> final TestSubscriber<?> ts;
<add>
<add> ScalarEmptyCancel(TestSubscriber<?> ts) {
<add> this.ts = ts;
<add> }
<add>
<add> @Override
<add> public @NonNull Integer get() throws Throwable {
<add> ts.cancel();
<add> return null;
<add> }
<add>
<add> @Override
<add> protected void subscribeActual(@NonNull Subscriber<@NonNull ? super @NonNull Integer> subscriber) {
<add> EmptySubscription.complete(subscriber);
<add> }
<add> }
<add>
<add> @Test
<add> public void someConcurrencyScalarInnerCancel() {
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> Flowable.just(1)
<add> .hide()
<add> .flatMap(v -> new ScalarEmptyCancel(ts))
<add> .subscribeWith(ts)
<add> .assertEmpty();
<add> }
<add>
<add> @Test
<add> public void allConcurrencyBackpressured() {
<add> Flowable.just(1)
<add> .hide()
<add> .flatMap(v -> Flowable.just(2), Integer.MAX_VALUE)
<add> .test(0L)
<add> .assertEmpty()
<add> .requestMore(1)
<add> .assertResult(2);
<add> }
<add>
<add> @Test
<add> public void someConcurrencyInnerScalarCancel() {
<add> Flowable.just(1)
<add> .hide()
<add> .flatMap(v -> Flowable.just(2), 2)
<add> .takeUntil(v -> true)
<add> .test()
<add> .assertResult(2);
<add> }
<add>
<add> @Test
<add> public void scalarInnerOuterOverflow() {
<add> new Flowable<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull Subscriber<@NonNull ? super @NonNull Integer> subscriber) {
<add> subscriber.onSubscribe(new BooleanSubscription());
<add> subscriber.onNext(1);
<add> subscriber.onNext(2);
<add> subscriber.onNext(3);
<add> }
<add> }
<add> .flatMap(v -> Flowable.just(v), 1)
<add> .test(0L)
<add> .assertFailure(MissingBackpressureException.class);
<add> }
<add>
<add> @Test
<add> public void scalarInnerOuterOverflowSlowPath() {
<add> AtomicReference<Subscriber<? super Integer>> ref = new AtomicReference<>();
<add> new Flowable<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull Subscriber<@NonNull ? super @NonNull Integer> subscriber) {
<add> subscriber.onSubscribe(new BooleanSubscription());
<add> ref.set(subscriber);
<add> subscriber.onNext(1);
<add> }
<add> }
<add> .flatMap(v -> Flowable.just(v), 1)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> ref.get().onNext(2);
<add> ref.get().onNext(3);
<add> }
<add> })
<add> .test()
<add> .assertFailure(MissingBackpressureException.class, 1);
<add> }
<add>
<add> @Test
<add> public void innerFastPathEmitOverflow() {
<add> Flowable.just(1)
<add> .hide()
<add> .flatMap(v -> new Flowable<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull Subscriber<@NonNull ? super @NonNull Integer> subscriber) {
<add> subscriber.onSubscribe(new BooleanSubscription());
<add> subscriber.onNext(1);
<add> subscriber.onNext(2);
<add> subscriber.onNext(3);
<add> }
<add> }, false, 1, 1)
<add> .test(0L)
<add> .assertFailure(MissingBackpressureException.class);
<add> }
<add>
<add> @Test
<add> public void takeFromScalarQueue() {
<add> Flowable.just(1)
<add> .hide()
<add> .flatMap(v -> Flowable.just(2), 2)
<add> .takeUntil(v -> true)
<add> .test(0L)
<add> .requestMore(2)
<add> .assertResult(2);
<add> }
<add>
<add> @Test
<add> public void scalarInnerQueueEmpty() {
<add> Flowable.just(1)
<add> .concatWith(Flowable.never())
<add> .hide()
<add> .flatMap(v -> Flowable.just(2), 2)
<add> .test(0L)
<add> .requestMore(2)
<add> .assertValuesOnly(2);
<add> }
<add>
<add> @Test
<add> public void innerCompletesAfterOnNextInDrainThenCancels() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<>(0L);
<add>
<add> Flowable.just(1)
<add> .hide()
<add> .flatMap(v -> pp)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onComplete();
<add> ts.cancel();
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> pp.onNext(1);
<add>
<add> ts
<add> .requestMore(1)
<add> .assertValuesOnly(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableForEachTest.java
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.*;
<add>import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public class FlowableForEachTest extends RxJavaTest {
<ide>
<ide> public void accept(Throwable e) throws Exception {
<ide> assertEquals(Arrays.asList(1, 2, 3, 4, 5, 100), list);
<ide> }
<ide>
<add> @Test
<add> public void dispose() {
<add> TestHelper.checkDisposed(
<add> Flowable.never()
<add> .forEachWhile(v -> true)
<add> );
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFromCompletableTest.java
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.functions.*;
<del>import io.reactivex.rxjava3.internal.fuseable.QueueFuseable;
<add>import io.reactivex.rxjava3.internal.fuseable.*;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> public void syncFusedRejected() throws Throwable {
<ide>
<ide> verify(action).run();
<ide> }
<add>
<add> @Test
<add> public void upstream() {
<add> Flowable<?> f = Flowable.fromCompletable(Completable.never());
<add> assertTrue(f instanceof HasUpstreamCompletableSource);
<add> assertSame(Completable.never(), ((HasUpstreamCompletableSource)f).source());
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFromIterableTest.java
<ide>
<ide> import java.util.*;
<ide> import java.util.concurrent.*;
<del>import java.util.concurrent.atomic.AtomicBoolean;
<add>import java.util.concurrent.atomic.*;
<ide>
<ide> import org.junit.Test;
<ide> import org.mockito.Mockito;
<ide> import org.reactivestreams.*;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.Function;
<ide> public void remove() {
<ide> .assertNoErrors()
<ide> .assertNotComplete();
<ide> }
<add>
<add> @Test
<add> public void hasNextCancelsAndCompletesFastPath() {
<add> final TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> Flowable.fromIterable(new Iterable<Integer>() {
<add> @Override
<add> public Iterator<Integer> iterator() {
<add> return new Iterator<Integer>() {
<add> int count;
<add>
<add> @Override
<add> public boolean hasNext() {
<add> if (++count == 2) {
<add> ts.cancel();
<add> return false;
<add> }
<add> return true;
<add> }
<add>
<add> @Override
<add> public Integer next() {
<add> return 1;
<add> }
<add>
<add> @Override
<add> public void remove() {
<add> throw new UnsupportedOperationException();
<add> }
<add> };
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> ts.assertValue(1)
<add> .assertNoErrors()
<add> .assertNotComplete();
<add> }
<add>
<add> @Test
<add> public void hasNextCancelsAndCompletesSlowPath() {
<add> final TestSubscriber<Integer> ts = new TestSubscriber<>(10L);
<add>
<add> Flowable.fromIterable(new Iterable<Integer>() {
<add> @Override
<add> public Iterator<Integer> iterator() {
<add> return new Iterator<Integer>() {
<add> int count;
<add>
<add> @Override
<add> public boolean hasNext() {
<add> if (++count == 2) {
<add> ts.cancel();
<add> return false;
<add> }
<add> return true;
<add> }
<add>
<add> @Override
<add> public Integer next() {
<add> return 1;
<add> }
<add>
<add> @Override
<add> public void remove() {
<add> throw new UnsupportedOperationException();
<add> }
<add> };
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> ts.assertValue(1)
<add> .assertNoErrors()
<add> .assertNotComplete();
<add> }
<add>
<add> @Test
<add> public void hasNextCancelsAndCompletesFastPathConditional() {
<add> final TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> Flowable.fromIterable(new Iterable<Integer>() {
<add> @Override
<add> public Iterator<Integer> iterator() {
<add> return new Iterator<Integer>() {
<add> int count;
<add>
<add> @Override
<add> public boolean hasNext() {
<add> if (++count == 2) {
<add> ts.cancel();
<add> return false;
<add> }
<add> return true;
<add> }
<add>
<add> @Override
<add> public Integer next() {
<add> return 1;
<add> }
<add>
<add> @Override
<add> public void remove() {
<add> throw new UnsupportedOperationException();
<add> }
<add> };
<add> }
<add> })
<add> .filter(v -> true)
<add> .subscribe(ts);
<add>
<add> ts.assertValue(1)
<add> .assertNoErrors()
<add> .assertNotComplete();
<add> }
<add>
<add> @Test
<add> public void hasNextCancelsAndCompletesSlowPathConditional() {
<add> final TestSubscriber<Integer> ts = new TestSubscriber<>(10);
<add>
<add> Flowable.fromIterable(new Iterable<Integer>() {
<add> @Override
<add> public Iterator<Integer> iterator() {
<add> return new Iterator<Integer>() {
<add> int count;
<add>
<add> @Override
<add> public boolean hasNext() {
<add> if (++count == 2) {
<add> ts.cancel();
<add> return false;
<add> }
<add> return true;
<add> }
<add>
<add> @Override
<add> public Integer next() {
<add> return 1;
<add> }
<add>
<add> @Override
<add> public void remove() {
<add> throw new UnsupportedOperationException();
<add> }
<add> };
<add> }
<add> })
<add> .filter(v -> true)
<add> .subscribe(ts);
<add>
<add> ts.assertValue(1)
<add> .assertNoErrors()
<add> .assertNotComplete();
<add> }
<add>
<add> @Test
<add> public void fusedPoll() throws Throwable {
<add> AtomicReference<SimpleQueue<?>> queue = new AtomicReference<>();
<add>
<add> Flowable.fromIterable(Arrays.asList(1))
<add> .subscribe(new FlowableSubscriber<Integer>() {
<add> @Override
<add> public void onSubscribe(@NonNull Subscription s) {
<add> queue.set((SimpleQueue<?>)s);
<add> ((QueueSubscription<?>)s).requestFusion(QueueFuseable.ANY);
<add> }
<add>
<add> @Override
<add> public void onNext(Integer t) {
<add> }
<add>
<add> @Override
<add> public void onError(Throwable t) {
<add> }
<add>
<add> @Override
<add> public void onComplete() {
<add> }
<add> });
<add>
<add> SimpleQueue<?> q = queue.get();
<add>
<add> assertFalse(q.isEmpty());
<add>
<add> assertEquals(1, q.poll());
<add>
<add> assertTrue(q.isEmpty());
<add>
<add> q.clear();
<add>
<add> assertTrue(q.isEmpty());
<add> }
<add>
<add> @Test
<add> public void disposeWhileIteratorNext() {
<add> final TestSubscriber<Integer> ts = new TestSubscriber<>(10);
<add>
<add> Flowable.fromIterable(new Iterable<Integer>() {
<add> @Override
<add> public Iterator<Integer> iterator() {
<add> return new Iterator<Integer>() {
<add> @Override
<add> public boolean hasNext() {
<add> return true;
<add> }
<add>
<add> @Override
<add> public Integer next() {
<add> ts.cancel();
<add> return 1;
<add> }
<add>
<add> @Override
<add> public void remove() {
<add> throw new UnsupportedOperationException();
<add> }
<add> };
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> ts.assertEmpty();
<add> }
<add>
<add> @Test
<add> public void disposeWhileIteratorNextConditional() {
<add> final TestSubscriber<Integer> ts = new TestSubscriber<>(10);
<add>
<add> Flowable.fromIterable(new Iterable<Integer>() {
<add> @Override
<add> public Iterator<Integer> iterator() {
<add> return new Iterator<Integer>() {
<add> @Override
<add> public boolean hasNext() {
<add> return true;
<add> }
<add>
<add> @Override
<add> public Integer next() {
<add> ts.cancel();
<add> return 1;
<add> }
<add>
<add> @Override
<add> public void remove() {
<add> throw new UnsupportedOperationException();
<add> }
<add> };
<add> }
<add> })
<add> .filter(v -> true)
<add> .subscribe(ts);
<add>
<add> ts.assertEmpty();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableGenerateTest.java
<ide> public void accept(Emitter<Object> e) throws Exception {
<ide> .test(1)
<ide> .assertResult();
<ide> }
<add>
<add> @Test
<add> public void onNextAfterOnComplete() {
<add> Flowable.generate(new Consumer<Emitter<Object>>() {
<add> @Override
<add> public void accept(Emitter<Object> e) throws Exception {
<add> e.onComplete();
<add> e.onNext(1);
<add> }
<add> })
<add> .test()
<add> .assertResult();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableGroupByTest.java
<ide>
<ide> public class FlowableGroupByTest extends RxJavaTest {
<ide>
<add> static Function<GroupedFlowable<Integer, Integer>, Flowable<Integer>> FLATTEN_INTEGER = new Function<GroupedFlowable<Integer, Integer>, Flowable<Integer>>() {
<add>
<add> @Override
<add> public Flowable<Integer> apply(GroupedFlowable<Integer, Integer> t) {
<add> return t;
<add> }
<add>
<add> };
<add>
<ide> final Function<String, Integer> length = new Function<String, Integer>() {
<ide> @Override
<ide> public Integer apply(String s) {
<ide> public String apply(Integer l) {
<ide> ts.assertNoErrors();
<ide> }
<ide>
<del> static Function<GroupedFlowable<Integer, Integer>, Flowable<Integer>> FLATTEN_INTEGER = new Function<GroupedFlowable<Integer, Integer>, Flowable<Integer>>() {
<del>
<del> @Override
<del> public Flowable<Integer> apply(GroupedFlowable<Integer, Integer> t) {
<del> return t;
<del> }
<del>
<del> };
<del>
<ide> @Test
<ide> public void groupByWithNullKey() {
<ide> final String[] key = new String[]{"uninitialized"};
<ide> public Object apply(Flowable<Object> f) throws Exception {
<ide>
<ide> @Test
<ide> public void badRequest() {
<del> TestHelper.assertBadRequestReported(Flowable.just(1)
<add> TestHelper.assertBadRequestReported(Flowable.just(1).hide()
<ide> .groupBy(Functions.justFunction(1)));
<ide> }
<ide>
<add> @Test
<add> public void badRequestInner() {
<add> Flowable.just(1).hide()
<add> .groupBy(Functions.justFunction(1))
<add> .doOnNext(g -> {
<add> TestHelper.assertBadRequestReported(g);
<add> })
<add> .test()
<add> .assertNoErrors();
<add> }
<add>
<ide> @Test
<ide> public void doubleOnSubscribe() {
<ide> TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Publisher<GroupedFlowable<Integer, Object>>>() {
<ide> public Map<Integer, Object> apply(final Consumer<Object> notify) throws Exceptio
<ide> .assertNoValues()
<ide> .assertError(ex);
<ide> }
<add> // -----------------------------------------------------------------------------------------------------------------------
<add>
<add> private static final Function<Integer, Integer> mod5 = new Function<Integer, Integer>() {
<add>
<add> @Override
<add> public Integer apply(Integer n) throws Exception {
<add> return n % 5;
<add> }
<add> };
<add>
<add> private static Function<GroupedFlowable<Integer, Integer>, Publisher<? extends Integer>> addCompletedKey(
<add> final List<Integer> completed) {
<add> return new Function<GroupedFlowable<Integer, Integer>, Publisher<? extends Integer>>() {
<add> @Override
<add> public Publisher<? extends Integer> apply(final GroupedFlowable<Integer, Integer> g) throws Exception {
<add> return g.doOnComplete(new Action() {
<add> @Override
<add> public void run() throws Exception {
<add> completed.add(g.getKey());
<add> }
<add> });
<add> }
<add> };
<add> }
<add>
<add> private static final class TestTicker extends Ticker {
<add> long tick;
<add>
<add> @Override
<add> public long read() {
<add> return tick;
<add> }
<add> }
<ide>
<ide> @Test
<ide> public void mapFactoryExpiryCompletesGroupedFlowable() {
<ide> public void mapFactoryExpiryCompletesGroupedFlowable() {
<ide> ts.assertValueCount(3);
<ide> }
<ide>
<del> private static final Function<Integer, Integer> mod5 = new Function<Integer, Integer>() {
<del>
<del> @Override
<del> public Integer apply(Integer n) throws Exception {
<del> return n % 5;
<del> }
<del> };
<del>
<del> @Test
<del> public void mapFactoryWithExpiringGuavaCacheDemonstrationCodeForUseInJavadoc() {
<del> //javadoc will be a version of this using lambdas and without assertions
<del> final List<Integer> completed = new CopyOnWriteArrayList<>();
<del> //size should be less than 5 to notice the effect
<del> Function<Consumer<Object>, Map<Integer, Object>> evictingMapFactory = createEvictingMapFactoryGuava(3);
<del> int numValues = 1000;
<del> TestSubscriber<Integer> ts =
<del> Flowable.range(1, numValues)
<del> .groupBy(mod5, Functions.<Integer>identity(), true, 16, evictingMapFactory)
<del> .flatMap(addCompletedKey(completed))
<del> .test()
<del> .assertComplete();
<del> ts.assertValueCount(numValues);
<del> //the exact eviction behaviour of the guava cache is not specified so we make some approximate tests
<del> assertTrue(completed.size() > numValues * 0.9);
<del> }
<del>
<ide> @Test
<ide> public void mapFactoryEvictionQueueClearedOnErrorCoverageOnly() {
<ide> Function<Consumer<Object>, Map<Integer, Object>> evictingMapFactory = createEvictingMapFactorySynchronousOnly(1);
<ide> public Publisher<Integer> apply(GroupedFlowable<Integer, Integer> g) throws Exce
<ide> .assertError(ex);
<ide> }
<ide>
<del> private static Function<GroupedFlowable<Integer, Integer>, Publisher<? extends Integer>> addCompletedKey(
<del> final List<Integer> completed) {
<del> return new Function<GroupedFlowable<Integer, Integer>, Publisher<? extends Integer>>() {
<del> @Override
<del> public Publisher<? extends Integer> apply(final GroupedFlowable<Integer, Integer> g) throws Exception {
<del> return g.doOnComplete(new Action() {
<del> @Override
<del> public void run() throws Exception {
<del> completed.add(g.getKey());
<del> }
<del> });
<del> }
<del> };
<del> }
<add> @Test
<add> public void mapFactoryWithExpiringGuavaCacheDemonstrationCodeForUseInJavadoc() {
<add> //javadoc will be a version of this using lambdas and without assertions
<add> final List<Integer> completed = new CopyOnWriteArrayList<>();
<ide>
<del> private static final class TestTicker extends Ticker {
<del> long tick;
<add> AtomicReference<Cache<Integer, Object>> cacheOut = new AtomicReference<>();
<ide>
<del> @Override
<del> public long read() {
<del> return tick;
<del> }
<add> //size should be less than 5 to notice the effect
<add> Function<Consumer<Object>, Map<Integer, Object>> evictingMapFactory = createEvictingMapFactoryGuava(3, cacheOut);
<add> int numValues = 1000;
<add> TestSubscriber<Integer> ts =
<add> Flowable.range(1, numValues)
<add> .groupBy(mod5, Functions.<Integer>identity(), true, 16, evictingMapFactory)
<add> .flatMap(addCompletedKey(completed))
<add> .test()
<add> .assertComplete()
<add> ;
<add> ts.assertValueCount(numValues);
<add> //the exact eviction behaviour of the guava cache is not specified so we make some approximate tests
<add> assertTrue(completed.size() > numValues * 0.9);
<add>
<add> cacheOut.get().invalidateAll();
<ide> }
<ide>
<ide> @Test
<ide> public void run() throws Exception {
<ide> ), list);
<ide> }
<ide>
<del> @Test
<del> public void cancellationOfUpstreamWhenGroupedFlowableCompletes() {
<del> final AtomicBoolean cancelled = new AtomicBoolean();
<del> Flowable.just(1).repeat().doOnCancel(new Action() {
<del> @Override
<del> public void run() throws Exception {
<del> cancelled.set(true);
<del> }
<del> })
<del> .groupBy(Functions.<Integer>identity(), Functions.<Integer>identity()) //
<del> .flatMap(new Function<GroupedFlowable<Integer, Integer>, Publisher<? extends Object>>() {
<del> @Override
<del> public Publisher<? extends Object> apply(GroupedFlowable<Integer, Integer> g) throws Exception {
<del> return g.first(0).toFlowable();
<del> }
<del> })
<del> .take(4) //
<del> .test() //
<del> .assertComplete();
<del> assertTrue(cancelled.get());
<del> }
<del>
<ide> //not thread safe
<ide> private static final class SingleThreadEvictingHashMap<K, V> implements Map<K, V> {
<ide>
<ide> public Set<Entry<K, V>> entrySet() {
<ide> }
<ide> }
<ide>
<del> private static Function<Consumer<Object>, Map<Integer, Object>> createEvictingMapFactoryGuava(final int maxSize) {
<add> private static Function<Consumer<Object>, Map<Integer, Object>> createEvictingMapFactoryGuava(final int maxSize,
<add> final AtomicReference<Cache<Integer, Object>> cacheOut) {
<ide> Function<Consumer<Object>, Map<Integer, Object>> evictingMapFactory = //
<ide> new Function<Consumer<Object>, Map<Integer, Object>>() {
<ide>
<ide> @Override
<ide> public Map<Integer, Object> apply(final Consumer<Object> notify) throws Exception {
<del> return CacheBuilder.newBuilder() //
<add> Cache<Integer, Object> cache = CacheBuilder.newBuilder() //
<ide> .maximumSize(maxSize) //
<ide> .removalListener(new RemovalListener<Integer, Object>() {
<ide> @Override
<ide> public void onRemoval(RemovalNotification<Integer, Object> notification) {
<ide> throw new RuntimeException(e);
<ide> }
<ide> }})
<del> .<Integer, Object> build()
<del> .asMap();
<add> .<Integer, Object> build();
<add> cacheOut.set(cache);
<add> return cache.asMap();
<ide> }};
<ide> return evictingMapFactory;
<ide> }
<ide> public void accept(Object object) {
<ide> return evictingMapFactory;
<ide> }
<ide>
<add> // -----------------------------------------------------------------------------------------------------------------------
<add>
<add> @Test
<add> public void cancellationOfUpstreamWhenGroupedFlowableCompletes() {
<add> final AtomicBoolean cancelled = new AtomicBoolean();
<add> Flowable.just(1).repeat().doOnCancel(new Action() {
<add> @Override
<add> public void run() throws Exception {
<add> cancelled.set(true);
<add> }
<add> })
<add> .groupBy(Functions.<Integer>identity(), Functions.<Integer>identity()) //
<add> .flatMap(new Function<GroupedFlowable<Integer, Integer>, Publisher<? extends Object>>() {
<add> @Override
<add> public Publisher<? extends Object> apply(GroupedFlowable<Integer, Integer> g) throws Exception {
<add> return g.first(0).toFlowable();
<add> }
<add> })
<add> .take(4) //
<add> .test() //
<add> .assertComplete();
<add> assertTrue(cancelled.get());
<add> }
<add>
<ide> @Test
<ide> public void cancelOverFlatmapRace() {
<ide> for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
<ide> public void run() throws Exception {
<ide>
<ide> assertEquals(1000, counter.get());
<ide> }
<add>
<add> @Test
<add> public void delayErrorCompleteMoreWorkInGroup() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = pp.groupBy(v -> 1, true)
<add> .flatMap(g -> g.doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onNext(2);
<add> pp.onComplete();
<add> }
<add> })
<add> )
<add> .test()
<add> ;
<add>
<add> pp.onNext(1);
<add>
<add> ts.assertResult(1, 2);
<add> }
<add>
<add> @Test
<add> public void groupSyncFusionRejected() {
<add> Flowable.just(1)
<add> .groupBy(v -> 1)
<add> .doOnNext(g -> {
<add> g.subscribeWith(new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.SYNC))
<add> .assertFuseable()
<add> .assertFusionMode(QueueFuseable.NONE);
<add> })
<add> .test()
<add> .assertComplete();
<add> }
<add>
<add> @Test
<add> public void subscribeAbandonRace() throws Throwable {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = TestSubscriber.create();
<add>
<add> CountDownLatch cdl = new CountDownLatch(1);
<add>
<add> pp.groupBy(v -> 1)
<add> .doOnNext(g -> {
<add> TestHelper.raceOther(() -> {
<add> g.subscribe(ts);
<add> }, cdl);
<add> })
<add> .test();
<add>
<add> pp.onNext(1);
<add>
<add> cdl.await();
<add>
<add> ts.assertValueCount(1);
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableGroupJoinTest.java
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.operators.flowable.FlowableGroupJoin.*;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<del>import io.reactivex.rxjava3.processors.PublishProcessor;
<add>import io.reactivex.rxjava3.processors.*;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public void leftRightEndState() {
<ide>
<ide> verify(js).innerClose(false, o);
<ide> }
<add>
<add> @Test
<add> public void disposeAfterOnNext() {
<add> PublishProcessor<Integer> pp1 = PublishProcessor.create();
<add> PublishProcessor<Integer> pp2 = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> pp1.groupJoin(pp2, v -> Flowable.never(), v -> Flowable.never(), (a, b) -> a)
<add> .doOnNext(v -> {
<add> ts.cancel();
<add> })
<add> .subscribe(ts);
<add>
<add> pp2.onNext(1);
<add> pp1.onNext(1);
<add> }
<add>
<add> @Test
<add> public void completeWithMoreWork() {
<add> PublishProcessor<Integer> pp1 = PublishProcessor.create();
<add> PublishProcessor<Integer> pp2 = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> pp1.groupJoin(pp2, v -> Flowable.never(), v -> Flowable.never(), (a, b) -> a)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp2.onNext(2);
<add> pp1.onComplete();
<add> pp2.onComplete();
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> pp2.onNext(1);
<add> pp1.onNext(1);
<add> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().groupJoin(Flowable.never(), v -> Flowable.never(), v -> Flowable.never(), (a, b) -> a));
<add> }
<add>
<add> @Test
<add> public void missingBackpressure() {
<add> Flowable.just(1)
<add> .groupJoin(Flowable.never(), v -> BehaviorProcessor.createDefault(1), v -> Flowable.never(), (a, b) -> a)
<add> .test(0)
<add> .assertFailure(MissingBackpressureException.class);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableIntervalRangeTest.java
<ide> public void cancel() {
<ide> .test()
<ide> .assertResult(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L);
<ide> }
<add>
<add> @Test
<add> public void takeSameAsRange() {
<add> Flowable.intervalRange(0, 2, 1, 1, TimeUnit.MILLISECONDS, Schedulers.trampoline())
<add> .take(2)
<add> .test()
<add> .assertResult(0L, 1L);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableJoinTest.java
<ide> public Object apply(Integer a, Integer b) throws Exception {
<ide>
<ide> ts.assertFailure(MissingBackpressureException.class);
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> PublishProcessor<Integer> pp1 = PublishProcessor.create();
<add> PublishProcessor<Integer> pp2 = PublishProcessor.create();
<add>
<add> TestHelper.assertBadRequestReported(pp1.join(pp2, Functions.justFunction(Flowable.never()), Functions.justFunction(Flowable.never()), (a, b) -> a + b));
<add> }
<add>
<add> @Test
<add> public void bothTerminateWithWorkRemaining() {
<add> PublishProcessor<Integer> pp1 = PublishProcessor.create();
<add> PublishProcessor<Integer> pp2 = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = pp1.join(
<add> pp2,
<add> v -> Flowable.never(),
<add> v -> Flowable.never(),
<add> (a, b) -> a + b)
<add> .doOnNext(v -> {
<add> pp1.onComplete();
<add> pp2.onNext(2);
<add> pp2.onComplete();
<add> })
<add> .test();
<add>
<add> pp1.onNext(0);
<add> pp2.onNext(1);
<add>
<add> ts.assertComplete();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableMergeWithMaybeTest.java
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.PublishProcessor;
<del>import io.reactivex.rxjava3.subjects.MaybeSubject;
<add>import io.reactivex.rxjava3.subjects.*;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public Flowable<Integer> apply(Flowable<Integer> upstream) {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void drainMoreWorkBeforeCancel() {
<add> MaybeSubject<Integer> ms = MaybeSubject.create();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> Flowable.range(1, 5).mergeWith(ms)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> ms.onSuccess(6);
<add> ts.cancel();
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> ts.assertValuesOnly(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableMergeWithSingleTest.java
<ide> public Flowable<Integer> apply(Flowable<Integer> upstream) {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void drainMoreWorkBeforeCancel() {
<add> SingleSubject<Integer> ss = SingleSubject.create();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> Flowable.range(1, 5).mergeWith(ss)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> ss.onSuccess(6);
<add> ts.cancel();
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> ts.assertValuesOnly(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableObserveOnTest.java
<ide> public Flowable<Object> apply(Flowable<Object> f) throws Exception {
<ide> });
<ide> }
<ide>
<add> @Test
<add> public void doubleOnSubscribeConditional() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Flowable<Object>>() {
<add> @Override
<add> public Flowable<Object> apply(Flowable<Object> f) throws Exception {
<add> return f.observeOn(new TestScheduler()).compose(TestHelper.conditional());
<add> }
<add> });
<add> }
<add>
<ide> @Test
<ide> public void badSource() {
<ide> List<Throwable> errors = TestHelper.trackPluginErrors();
<ide> public void fusedParallelProcessing() {
<ide> .assertComplete()
<ide> .assertNoErrors();
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().observeOn(ImmediateThinScheduler.INSTANCE));
<add> }
<add>
<add> @Test
<add> public void syncFusedCancelAfterPoll() {
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> Flowable.just(1)
<add> .map(v -> {
<add> ts.cancel();
<add> return v + 1;
<add> })
<add> .compose(TestHelper.flowableStripBoundary())
<add> .observeOn(ImmediateThinScheduler.INSTANCE)
<add> .subscribe(ts);
<add>
<add> ts.assertEmpty();
<add> }
<add>
<add> @Test
<add> public void syncFusedCancelAfterPollConditional() {
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> Flowable.just(1)
<add> .map(v -> {
<add> ts.cancel();
<add> return v + 1;
<add> })
<add> .compose(TestHelper.flowableStripBoundary())
<add> .observeOn(ImmediateThinScheduler.INSTANCE)
<add> .compose(TestHelper.conditional())
<add> .subscribe(ts);
<add>
<add> ts.assertEmpty();
<add> }
<add>
<add> @Test
<add> public void backFusedMoreWork() {
<add> final TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.ANY);
<add>
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> pp.observeOn(ImmediateThinScheduler.INSTANCE)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onNext(2);
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> pp.onNext(1);
<add>
<add> ts.assertValuesOnly(1, 2);
<add> }
<add>
<add> @Test
<add> public void moreWorkInRunAsync() {
<add> final TestSubscriberEx<Integer> ts = new TestSubscriberEx<>();
<add>
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> pp.observeOn(ImmediateThinScheduler.INSTANCE)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onNext(2);
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> pp.onNext(1);
<add>
<add> ts.assertValuesOnly(1, 2);
<add> }
<add>
<add> @Test
<add> public void backFusedConditionalMoreWork() {
<add> final TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.ANY);
<add>
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> pp.observeOn(ImmediateThinScheduler.INSTANCE)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onNext(2);
<add> }
<add> })
<add> .compose(TestHelper.conditional())
<add> .subscribe(ts);
<add>
<add> pp.onNext(1);
<add>
<add> ts.assertValuesOnly(1, 2);
<add> }
<add>
<add> @Test
<add> public void conditionalMoreWorkInRunAsync() {
<add> final TestSubscriberEx<Integer> ts = new TestSubscriberEx<>();
<add>
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> pp.observeOn(ImmediateThinScheduler.INSTANCE)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onNext(2);
<add> }
<add> })
<add> .compose(TestHelper.conditional())
<add> .subscribe(ts);
<add>
<add> pp.onNext(1);
<add>
<add> ts.assertValuesOnly(1, 2);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableOnBackpressureBufferStrategyTest.java
<ide> public void justTake() {
<ide> .test()
<ide> .assertResult(1);
<ide> }
<add>
<add> @Test
<add> public void overflowNullAction() {
<add> Flowable.range(1, 5)
<add> .onBackpressureBuffer(1, null, BackpressureOverflowStrategy.DROP_OLDEST)
<add> .test(0L)
<add> .assertEmpty();
<add> }
<add>
<add> @Test
<add> public void cancelOnDrain() {
<add> Flowable.range(1, 5)
<add> .onBackpressureBuffer(10, null, BackpressureOverflowStrategy.DROP_OLDEST)
<add> .takeUntil(v -> true)
<add> .test(0L)
<add> .assertEmpty()
<add> .requestMore(10)
<add> .assertResult(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableOnBackpressureBufferTest.java
<ide> public void fusedNoConcurrentCleanDueToCancel() {
<ide> }
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> f.onBackpressureBuffer());
<add> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().onBackpressureBuffer());
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowablePublishTest.java
<ide> public void disposeResets() {
<ide>
<ide> ts.assertValuesOnly(1);
<ide> }
<add>
<add> @Test(expected = TestException.class)
<add> public void connectDisposeCrash() {
<add> ConnectableFlowable<Object> cf = Flowable.never().publish();
<add>
<add> cf.connect();
<add>
<add> cf.connect(d -> { throw new TestException(); });
<add> }
<add>
<add> @Test
<add> public void resetWhileNotConnectedIsNoOp() {
<add> ConnectableFlowable<Object> cf = Flowable.never().publish();
<add>
<add> cf.reset();
<add> }
<add>
<add> @Test
<add> public void resetWhileActiveIsNoOp() {
<add> ConnectableFlowable<Object> cf = Flowable.never().publish();
<add>
<add> cf.connect();
<add>
<add> cf.reset();
<add> }
<add>
<add> @Test
<add> public void crossCancelOnComplete() {
<add> TestSubscriber<Integer> ts1 = new TestSubscriber<>();
<add> TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onComplete() {
<add> super.onComplete();
<add> ts1.cancel();
<add> }
<add> };
<add>
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> ConnectableFlowable<Integer> cf = pp.publish();
<add>
<add> cf.subscribe(ts2);
<add> cf.subscribe(ts1);
<add>
<add> cf.connect();
<add>
<add> pp.onComplete();
<add>
<add> ts2.assertResult();
<add>
<add> ts1.assertEmpty();
<add> }
<add>
<add> @Test
<add> public void crossCancelOnError() {
<add> TestSubscriber<Integer> ts1 = new TestSubscriber<>();
<add> TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onError(Throwable t) {
<add> super.onError(t);
<add> ts1.cancel();
<add> }
<add> };
<add>
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> ConnectableFlowable<Integer> cf = pp.publish();
<add>
<add> cf.subscribe(ts2);
<add> cf.subscribe(ts1);
<add>
<add> cf.connect();
<add>
<add> pp.onError(new TestException());
<add>
<add> ts2.assertFailure(TestException.class);
<add>
<add> ts1.assertEmpty();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableRangeLongTest.java
<ide> public boolean test(Long v) throws Exception {
<ide>
<ide> ts.assertResult(2L, 4L);
<ide> }
<add>
<add> @Test
<add> public void slowPathCancelBeforeComplete() {
<add> Flowable.rangeLong(1, 2)
<add> .take(2)
<add> .test()
<add> .assertResult(1L, 2L);
<add> }
<add>
<add> @Test
<add> public void conditionalFastPathCancelBeforeComplete() {
<add> TestSubscriber<Long> ts = new TestSubscriber<>();
<add>
<add> Flowable.rangeLong(1, 2)
<add> .compose(TestHelper.conditional())
<add> .doOnNext(v -> {
<add> if (v == 2L) {
<add> ts.cancel();
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> ts.assertValuesOnly(1L, 2L);
<add> }
<add>
<add> @Test
<add> public void conditionalSlowPathTake() {
<add> TestSubscriber<Long> ts = new TestSubscriber<>(4);
<add>
<add> Flowable.rangeLong(1, 3)
<add> .compose(TestHelper.conditional())
<add> .doOnNext(v -> {
<add> if (v == 2L) {
<add> ts.cancel();
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> ts.assertValuesOnly(1L, 2L);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableRangeTest.java
<ide> public void onNext(Integer t) {
<ide>
<ide> ts.assertResult(1, 2);
<ide> }
<add>
<add> @Test
<add> public void slowPathCancelBeforeComplete() {
<add> Flowable.range(1, 2)
<add> .take(2)
<add> .test()
<add> .assertResult(1, 2);
<add> }
<add>
<add> @Test
<add> public void conditionalFastPatchCancelBeforeComplete() {
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add>
<add> Flowable.range(1, 2)
<add> .compose(TestHelper.conditional())
<add> .doOnNext(v -> {
<add> if (v == 2) {
<add> ts.cancel();
<add> }
<add> })
<add> .subscribe(ts);
<add>
<add> ts.assertValuesOnly(1, 2);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableReduceTest.java
<ide> public Integer apply(Integer a, Integer b) throws Exception {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribeFlowable() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> f.reduce((a, b) -> a).toFlowable());
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableRefCountTest.java
<ide> public class FlowableRefCountTest extends RxJavaTest {
<ide>
<ide> @Test
<del> public void refCountAsync() {
<add> public void refCountAsync() throws InterruptedException {
<add> // Flaky
<add> for (int i = 0; i < 10; i++) {
<add> try {
<add> refCountAsyncActual();
<add> return;
<add> } catch (AssertionError ex) {
<add> if (i == 9) {
<add> throw ex;
<add> }
<add> Thread.sleep((int)(200 * (Math.random() * 10 + 1)));
<add> }
<add> }
<add> }
<add>
<add> /**
<add> * Tries to coordinate async counting but it is flaky due to the low 10s of milliseconds.
<add> */
<add> void refCountAsyncActual() {
<ide> final AtomicInteger subscribeCount = new AtomicInteger();
<ide> final AtomicInteger nextCount = new AtomicInteger();
<ide> Flowable<Long> r = Flowable.interval(0, 20, TimeUnit.MILLISECONDS)
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableReplayEagerTruncateTest.java
<ide> public boolean isDisposed() {
<ide>
<ide> @Test
<ide> public void boundedReplayBuffer() {
<del> BoundedReplayBuffer<Integer> buf = new BoundedReplayBuffer<>(true);
<add> BoundedReplayBuffer<Integer> buf = new BoundedReplayBuffer<Integer>(true) {
<add> private static final long serialVersionUID = -9081211580719235896L;
<add>
<add> @Override
<add> void truncate() {
<add> }
<add> };
<add>
<ide> buf.addLast(new Node(1, 0));
<ide> buf.addLast(new Node(2, 1));
<ide> buf.addLast(new Node(3, 2));
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableReplayTest.java
<ide> import static org.mockito.ArgumentMatchers.*;
<ide> import static org.mockito.Mockito.*;
<ide>
<add>import java.io.IOException;
<ide> import java.lang.management.*;
<ide> import java.util.*;
<ide> import java.util.concurrent.*;
<ide> import io.reactivex.rxjava3.internal.fuseable.HasUpstreamPublisher;
<ide> import io.reactivex.rxjava3.internal.operators.flowable.FlowableReplay.*;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<add>import io.reactivex.rxjava3.internal.util.BackpressureHelper;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.PublishProcessor;
<ide> import io.reactivex.rxjava3.schedulers.*;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public class FlowableReplayTest extends RxJavaTest {
<add>
<ide> @Test
<ide> public void bufferedReplay() {
<ide> PublishProcessor<Integer> source = PublishProcessor.create();
<ide> public boolean isDisposed() {
<ide>
<ide> @Test
<ide> public void boundedReplayBuffer() {
<del> BoundedReplayBuffer<Integer> buf = new BoundedReplayBuffer<>(false);
<add> BoundedReplayBuffer<Integer> buf = new BoundedReplayBuffer<Integer>(false) {
<add> private static final long serialVersionUID = -9081211580719235896L;
<add>
<add> @Override
<add> void truncate() {
<add> }
<add> };
<add>
<ide> buf.addLast(new Node(1, 0));
<ide> buf.addLast(new Node(2, 1));
<ide> buf.addLast(new Node(3, 2));
<ide> public void boundedReplayBuffer() {
<ide>
<ide> }
<ide>
<add> @Test(expected = IllegalStateException.class)
<add> public void boundedRemoveFirstOneItemOnly() {
<add> BoundedReplayBuffer<Integer> buf = new BoundedReplayBuffer<Integer>(false) {
<add> private static final long serialVersionUID = -9081211580719235896L;
<add>
<add> @Override
<add> void truncate() {
<add> }
<add> };
<add>
<add> buf.removeFirst();
<add> }
<add>
<ide> @Test
<ide> public void timedAndSizedTruncation() {
<ide> TestScheduler test = new TestScheduler();
<ide> public void take() {
<ide> TestSubscriberEx<Integer> ts = new TestSubscriberEx<>();
<ide>
<ide> Flowable<Integer> cached = Flowable.range(1, 100).replay().autoConnect();
<del> cached.take(10).subscribe(ts);
<add> cached
<add> .take(10)
<add> .subscribe(ts);
<ide>
<ide> ts.assertNoErrors();
<ide> ts.assertTerminated();
<ide> public void valuesAndThenError() {
<ide> }
<ide>
<ide> @Test
<del> public void unsafeChildThrows() {
<add> public void unsafeChildOnNextThrows() {
<ide> final AtomicInteger count = new AtomicInteger();
<ide>
<ide> Flowable<Integer> source = Flowable.range(1, 100)
<ide> public void onNext(Integer t) {
<ide> ts.assertError(TestException.class);
<ide> }
<ide>
<add> @Test
<add> public void unsafeChildOnErrorThrows() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> Flowable<Integer> source = Flowable.<Integer>error(new IOException())
<add> .replay()
<add> .autoConnect();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onError(Throwable t) {
<add> super.onError(t);
<add> throw new TestException();
<add> }
<add> };
<add>
<add> source.subscribe(ts);
<add>
<add> ts.assertFailure(IOException.class);
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> });
<add> }
<add>
<add> @Test
<add> public void unsafeChildOnCompleteThrows() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> Flowable<Integer> source = Flowable.<Integer>empty()
<add> .replay()
<add> .autoConnect();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onComplete() {
<add> super.onComplete();
<add> throw new TestException();
<add> }
<add> };
<add>
<add> source.subscribe(ts);
<add>
<add> ts.assertResult();
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> });
<add> }
<add>
<ide> @Test
<ide> public void unboundedLeavesEarly() {
<ide> PublishProcessor<Integer> source = PublishProcessor.create();
<ide> public void accept(byte[] v) throws Exception {
<ide> + " -> " + after.get() / 1024.0 / 1024.0);
<ide> }
<ide> }
<add>
<add> @Test
<add> public void unsafeChildOnNextThrowsSizeBound() {
<add> final AtomicInteger count = new AtomicInteger();
<add>
<add> Flowable<Integer> source = Flowable.range(1, 100)
<add> .doOnNext(new Consumer<Integer>() {
<add> @Override
<add> public void accept(Integer t) {
<add> count.getAndIncrement();
<add> }
<add> })
<add> .replay(1000).autoConnect();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onNext(Integer t) {
<add> throw new TestException();
<add> }
<add> };
<add>
<add> source.subscribe(ts);
<add>
<add> Assert.assertEquals(100, count.get());
<add>
<add> ts.assertNoValues();
<add> ts.assertNotComplete();
<add> ts.assertError(TestException.class);
<add> }
<add>
<add> @Test
<add> public void unsafeChildOnErrorThrowsSizeBound() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> Flowable<Integer> source = Flowable.<Integer>error(new IOException())
<add> .replay(1000)
<add> .autoConnect();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onError(Throwable t) {
<add> super.onError(t);
<add> throw new TestException();
<add> }
<add> };
<add>
<add> source.subscribe(ts);
<add>
<add> ts.assertFailure(IOException.class);
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> });
<add> }
<add>
<add> @Test
<add> public void unsafeChildOnCompleteThrowsSizeBound() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> Flowable<Integer> source = Flowable.<Integer>empty()
<add> .replay(1000)
<add> .autoConnect();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onComplete() {
<add> super.onComplete();
<add> throw new TestException();
<add> }
<add> };
<add>
<add> source.subscribe(ts);
<add>
<add> ts.assertResult();
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> });
<add> }
<add>
<add> @Test(expected = TestException.class)
<add> public void connectDisposeCrash() {
<add> ConnectableFlowable<Object> cf = Flowable.never().replay();
<add>
<add> cf.connect();
<add>
<add> cf.connect(d -> { throw new TestException(); });
<add> }
<add>
<add> @Test
<add> public void resetWhileNotConnectedIsNoOp() {
<add> ConnectableFlowable<Object> cf = Flowable.never().replay();
<add>
<add> cf.reset();
<add> }
<add>
<add> @Test
<add> public void resetWhileActiveIsNoOp() {
<add> ConnectableFlowable<Object> cf = Flowable.never().replay();
<add>
<add> cf.connect();
<add>
<add> cf.reset();
<add> }
<add>
<add> @Test
<add> public void delayedUpstreamSubscription() {
<add> AtomicReference<Subscriber<? super Integer>> ref = new AtomicReference<>();
<add> Flowable<Integer> f = Flowable.<Integer>unsafeCreate(ref::set);
<add>
<add> TestSubscriber<Integer> ts = f.replay()
<add> .autoConnect()
<add> .test();
<add>
<add> AtomicLong requested = new AtomicLong();
<add>
<add> ref.get().onSubscribe(new Subscription() {
<add> @Override
<add> public void request(long n) {
<add> BackpressureHelper.add(requested, n);
<add> }
<add>
<add> @Override
<add> public void cancel() {
<add> }
<add> });
<add>
<add> assertEquals(Long.MAX_VALUE, requested.get());
<add> ref.get().onComplete();
<add>
<add> ts.assertResult();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableSampleTest.java
<ide> public void badRequest() {
<ide> TestHelper.assertBadRequestReported(PublishProcessor.create()
<ide> .sample(PublishProcessor.create()));
<ide> }
<add>
<add> @Test
<add> public void badRequestTimed() {
<add> TestHelper.assertBadRequestReported(PublishProcessor.create()
<add> .sample(1, TimeUnit.MINUTES));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableScalarXMapTest.java
<ide> public void cancelled() {
<ide>
<ide> assertTrue(scalar.isCancelled());
<ide> }
<add>
<add> @Test
<add> public void mapToNonScalar() {
<add> Flowable.fromCallable(() -> 1)
<add> .concatMap(v -> Flowable.range(1, 5))
<add> .test()
<add> .assertResult(1, 2, 3, 4, 5);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableScanTest.java
<ide> public Integer apply(Integer a, Integer b) throws Exception {
<ide> }
<ide> }
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.<Integer>never().scanWith(() -> 1, (a, b) -> a + b));
<add> }
<add>
<add> @Test
<add> public void drainMoreWork() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = pp.scanWith(() -> 0, (a, b) -> a + b)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onNext(2);
<add> pp.onComplete();
<add> }
<add> })
<add> .test();
<add>
<add> pp.onNext(1);
<add>
<add> ts.assertResult(0, 1, 3);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableSequenceEqualTest.java
<ide> public Flowable<Boolean> apply(Flowable<Integer> upstream) {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void fusionRejected() {
<add> Flowable.sequenceEqual(TestHelper.rejectFlowableFusion(), Flowable.never())
<add> .test()
<add> .assertEmpty();
<add> }
<add>
<add> @Test
<add> public void fusionRejectedFlowable() {
<add> Flowable.sequenceEqual(TestHelper.rejectFlowableFusion(), Flowable.never())
<add> .toFlowable()
<add> .test()
<add> .assertEmpty();
<add> }
<add>
<add> @Test
<add> public void asyncSourceCompare() {
<add> Flowable.sequenceEqual(Flowable.fromCallable(() -> 1), Flowable.just(1))
<add> .test()
<add> .assertResult(true);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableSingleTest.java
<ide> public void singleOrError() {
<ide> .test()
<ide> .assertFailure(NoSuchElementException.class);
<ide> }
<add>
<add> @Test
<add> public void dispose() {
<add> TestHelper.checkDisposed(PublishProcessor.create().single(1));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableSkipLastTimedTest.java
<ide> public void observeOn() {
<ide> .assertComplete()
<ide> .assertNoErrors();
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().skipLast(1, TimeUnit.MINUTES));
<add> }
<add>
<add> @Test
<add> public void delayErrorMoreWork() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = pp.skipLast(0, TimeUnit.MILLISECONDS, true)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> pp.onNext(1);
<add> pp.onComplete();
<add> }
<add> })
<add> .test();
<add>
<add> pp.onNext(1);
<add>
<add> ts.assertComplete();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableSubscribeOnTest.java
<ide> import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.operators.flowable.FlowableSubscribeOn.SubscribeOnSubscriber;
<add>import io.reactivex.rxjava3.internal.schedulers.ImmediateThinScheduler;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.schedulers.*;
<ide> import io.reactivex.rxjava3.subscribers.*;
<ide> public void subscribe(FlowableEmitter<Object> s) throws Exception {
<ide> .assertNoErrors()
<ide> .assertComplete();
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().subscribeOn(ImmediateThinScheduler.INSTANCE));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableSwitchTest.java
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.internal.util.ExceptionHelper;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<del>import io.reactivex.rxjava3.processors.PublishProcessor;
<add>import io.reactivex.rxjava3.processors.*;
<ide> import io.reactivex.rxjava3.schedulers.*;
<ide> import io.reactivex.rxjava3.subscribers.*;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide> public Publisher<Integer> apply(Integer v)
<ide> .test()
<ide> .assertResult(10, 20);
<ide> }
<add>
<add> @Test
<add> public void asyncFusedInner() {
<add> Flowable.just(1)
<add> .hide()
<add> .switchMap(v -> Flowable.fromCallable(() -> 1))
<add> .test()
<add> .assertResult(1);
<add> }
<add>
<add> @Test
<add> public void innerIgnoresCancelAndErrors() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Object> ts = pp
<add> .switchMap(v -> {
<add> if (v == 1) {
<add> return Flowable.unsafeCreate(s -> {
<add> s.onSubscribe(new BooleanSubscription());
<add> pp.onNext(2);
<add> s.onError(new TestException());
<add> });
<add> }
<add> return Flowable.never();
<add> })
<add> .test();
<add>
<add> pp.onNext(1);
<add>
<add> ts.assertEmpty();
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> });
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> f.switchMap(v -> Flowable.never()));
<add> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().switchMap(v -> Flowable.never()));
<add> }
<add>
<add> @Test
<add> public void innerFailed() {
<add> BehaviorProcessor.createDefault(Flowable.error(new TestException()))
<add> .switchMap(v -> v)
<add> .test()
<add> .assertFailure(TestException.class)
<add> ;
<add> }
<add>
<add> @Test
<add> public void innerCompleted() {
<add> BehaviorProcessor.createDefault(Flowable.empty().hide())
<add> .switchMap(v -> v)
<add> .test()
<add> .assertEmpty()
<add> ;
<add> }
<add>
<add> @Test
<add> public void innerCompletedBackpressureBoundary() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = BehaviorProcessor.createDefault(pp)
<add> .onBackpressureBuffer()
<add> .switchMap(v -> v)
<add> .test(1L)
<add> ;
<add>
<add> ts.assertEmpty();
<add>
<add> pp.onNext(1);
<add> pp.onComplete();
<add>
<add> ts.assertValuesOnly(1);
<add> }
<add>
<add> @Test
<add> public void innerCompletedDelayError() {
<add> BehaviorProcessor.createDefault(Flowable.empty().hide())
<add> .switchMapDelayError(v -> v)
<add> .test()
<add> .assertEmpty()
<add> ;
<add> }
<add>
<add> @Test
<add> public void innerCompletedBackpressureBoundaryDelayError() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = BehaviorProcessor.createDefault(pp)
<add> .onBackpressureBuffer()
<add> .switchMapDelayError(v -> v)
<add> .test(1L)
<add> ;
<add>
<add> ts.assertEmpty();
<add>
<add> pp.onNext(1);
<add> pp.onComplete();
<add>
<add> ts.assertValuesOnly(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTakeLastTest.java
<ide>
<ide> import org.junit.Test;
<ide> import org.mockito.InOrder;
<del>import org.reactivestreams.Subscriber;
<add>import org.reactivestreams.*;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> public void takeLastTake() {
<ide> .test()
<ide> .assertResult(6, 7);
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().takeLast(2));
<add> }
<add>
<add> @Test
<add> public void cancelThenRequest() {
<add> Flowable.never().takeLast(2)
<add> .subscribe(new FlowableSubscriber<Object>() {
<add>
<add> @Override
<add> public void onNext(@NonNull Object t) {
<add> }
<add>
<add> @Override
<add> public void onError(Throwable t) {
<add> }
<add>
<add> @Override
<add> public void onComplete() {
<add> }
<add>
<add> @Override
<add> public void onSubscribe(@NonNull Subscription s) {
<add> s.cancel();
<add> s.request(1);
<add> }
<add> });
<add> }
<add>
<add> @Test
<add> public void noRequestEmpty() {
<add> Flowable.empty()
<add> .takeLast(2)
<add> .test(0L)
<add> .assertResult();
<add> }
<add>
<add> @Test
<add> public void moreValuesRemainingThanRequested() {
<add> Flowable.range(1, 4)
<add> .takeLast(3)
<add> .test(0L)
<add> .assertEmpty()
<add> .requestMore(2)
<add> .assertValuesOnly(2, 3)
<add> .requestMore(2)
<add> .assertResult(2, 3, 4);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableThrottleFirstTest.java
<ide> public void backpressureNoRequest() {
<ide> .test(0L)
<ide> .assertFailure(MissingBackpressureException.class);
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().throttleFirst(1, TimeUnit.MINUTES));
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> f.throttleFirst(1, TimeUnit.MINUTES));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTimeoutTests.java
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.PublishProcessor;
<del>import io.reactivex.rxjava3.schedulers.TestScheduler;
<add>import io.reactivex.rxjava3.schedulers.*;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public void run() {
<ide> }
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribeFallback() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> f.timeout(1, TimeUnit.MINUTES, Flowable.<Object>never()));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTimeoutWithSelectorTest.java
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<add>import io.reactivex.rxjava3.internal.operators.flowable.FlowableTimeout.TimeoutConsumer;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.*;
<ide> protected void subscribeActual(Subscriber<? super Integer> s) {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void timeoutConsumerIsDisposed() {
<add> TimeoutConsumer consumer = new TimeoutConsumer(0, null);
<add>
<add> assertFalse(consumer.isDisposed());
<add> consumer.dispose();
<add> assertTrue(consumer.isDisposed());
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableTimerTest.java
<ide> public Long apply(Long v) throws Exception {
<ide> exec.shutdown();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.timer(1, TimeUnit.MINUTES));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableUnsubscribeOnTest.java
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.Action;
<add>import io.reactivex.rxjava3.internal.schedulers.ImmediateThinScheduler;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> protected void subscribeActual(Subscriber<? super Integer> subscriber) {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> f.unsubscribeOn(ImmediateThinScheduler.INSTANCE));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableWindowWithSizeTest.java
<ide> public void accept(Flowable<Integer> v) throws Throwable {
<ide>
<ide> inner.get().test().assertResult(1);
<ide> }
<add>
<add> @Test
<add> public void badRequestExact() {
<add> TestHelper.assertBadRequestReported(Flowable.never().window(1));
<add> }
<add>
<add> @Test
<add> public void badRequestSkip() {
<add> TestHelper.assertBadRequestReported(Flowable.never().window(1, 2));
<add> }
<add>
<add> @Test
<add> public void badRequestOverlap() {
<add> TestHelper.assertBadRequestReported(Flowable.never().window(2, 1));
<add> }
<add>
<add> @Test
<add> public void skipEmpty() {
<add> Flowable.empty()
<add> .window(1, 2)
<add> .test()
<add> .assertResult();
<add> }
<add>
<add> @Test
<add> public void exactEmpty() {
<add> Flowable.empty()
<add> .window(2)
<add> .test()
<add> .assertResult();
<add> }
<add>
<add> @Test
<add> public void skipMultipleRequests() {
<add> Flowable.range(1, 10)
<add> .window(1, 2)
<add> .doOnNext(w -> w.test())
<add> .rebatchRequests(1)
<add> .test()
<add> .assertComplete();
<add> }
<add>
<add> @Test
<add> public void skipOne() {
<add> Flowable.just(1)
<add> .window(2, 3)
<add> .flatMap(v -> v)
<add> .test()
<add> .assertResult(1);
<add> }
<add>
<add> @Test
<add> public void overlapMultipleRequests() {
<add> Flowable.range(1, 10)
<add> .window(2, 1)
<add> .doOnNext(w -> w.test())
<add> .rebatchRequests(1)
<add> .test()
<add> .assertComplete();
<add> }
<add>
<add> @Test
<add> public void overlapCancelAfterWindow() {
<add> Flowable.range(1, 10)
<add> .window(2, 1)
<add> .takeUntil(v -> true)
<add> .doOnNext(w -> w.test())
<add> .test(0L)
<add> .requestMore(10)
<add> .assertComplete();
<add> }
<add>
<add> @Test
<add> public void overlapEmpty() {
<add> Flowable.empty()
<add> .window(2, 1)
<add> .test()
<add> .assertResult();
<add> }
<add>
<add> @Test
<add> public void overlapEmptyNoRequest() {
<add> Flowable.empty()
<add> .window(2, 1)
<add> .test(0L)
<add> .assertResult();
<add> }
<add>
<add> @Test
<add> public void overlapMoreWorkAfterOnNext() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add> AtomicBoolean once = new AtomicBoolean();
<add>
<add> TestSubscriber<Flowable<Integer>> ts = pp.window(2, 1)
<add> .doOnNext(v -> {
<add> v.test();
<add> if (once.compareAndSet(false, true)) {
<add> pp.onNext(2);
<add> pp.onComplete();
<add> }
<add> })
<add> .test();
<add>
<add> pp.onNext(1);
<add>
<add> ts.assertComplete();
<add> }
<add>
<add> @Test
<add> public void moreQueuedClean() {
<add> Flowable.range(1, 10)
<add> .window(5, 1)
<add> .doOnNext(w -> w.test())
<add> .test(3)
<add> .cancel();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableWindowWithStartEndFlowableTest.java
<ide>
<ide> import static org.junit.Assert.*;
<ide>
<add>import java.io.IOException;
<ide> import java.util.*;
<ide> import java.util.concurrent.TimeUnit;
<ide> import java.util.concurrent.atomic.*;
<ide> public void dispose() {
<ide>
<ide> @Test
<ide> public void reentrant() {
<del> final FlowableProcessor<Integer> ps = PublishProcessor.<Integer>create();
<add> final FlowableProcessor<Integer> pp = PublishProcessor.<Integer>create();
<ide>
<ide> TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
<ide> @Override
<ide> public void onNext(Integer t) {
<ide> super.onNext(t);
<ide> if (t == 1) {
<del> ps.onNext(2);
<del> ps.onComplete();
<add> pp.onNext(2);
<add> pp.onComplete();
<ide> }
<ide> }
<ide> };
<ide>
<del> ps.window(BehaviorProcessor.createDefault(1), Functions.justFunction(Flowable.never()))
<add> pp.window(BehaviorProcessor.createDefault(1), Functions.justFunction(Flowable.never()))
<ide> .flatMap(new Function<Flowable<Integer>, Flowable<Integer>>() {
<ide> @Override
<ide> public Flowable<Integer> apply(Flowable<Integer> v) throws Exception {
<ide> public Flowable<Integer> apply(Flowable<Integer> v) throws Exception {
<ide> })
<ide> .subscribe(ts);
<ide>
<del> ps.onNext(1);
<add> pp.onNext(1);
<ide>
<ide> ts
<ide> .awaitDone(1, TimeUnit.SECONDS)
<ide> public Publisher<Object> apply(Integer end) throws Throwable {
<ide> assertFalse(boundary.hasSubscribers());
<ide>
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(o -> o.window(Flowable.never(), v -> Flowable.never()));
<add> }
<add>
<add> @Test
<add> public void openError() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> TestException ex1 = new TestException();
<add> TestException ex2 = new TestException();
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> AtomicReference<Subscriber<? super Integer>> ref1 = new AtomicReference<>();
<add> AtomicReference<Subscriber<? super Integer>> ref2 = new AtomicReference<>();
<add>
<add> Flowable<Integer> f1 = Flowable.<Integer>fromPublisher(ref1::set);
<add> Flowable<Integer> f2 = Flowable.<Integer>fromPublisher(ref2::set);
<add>
<add> TestSubscriber<Flowable<Integer>> ts = BehaviorProcessor.createDefault(1)
<add> .window(f1, v -> f2)
<add> .doOnNext(w -> w.test())
<add> .test();
<add>
<add> ref1.get().onSubscribe(new BooleanSubscription());
<add> ref1.get().onNext(1);
<add> ref2.get().onSubscribe(new BooleanSubscription());
<add>
<add> TestHelper.race(
<add> () -> ref1.get().onError(ex1),
<add> () -> ref2.get().onError(ex2)
<add> );
<add>
<add> ts.assertError(RuntimeException.class);
<add>
<add> if (!errors.isEmpty()) {
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> }
<add>
<add> errors.clear();
<add> }
<add> });
<add> }
<add>
<add> @Test
<add> public void closeError() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> AtomicReference<Subscriber<? super Integer>> ref1 = new AtomicReference<>();
<add> AtomicReference<Subscriber<? super Integer>> ref2 = new AtomicReference<>();
<add>
<add> Flowable<Integer> f1 = Flowable.<Integer>unsafeCreate(ref1::set);
<add> Flowable<Integer> f2 = Flowable.<Integer>unsafeCreate(ref2::set);
<add>
<add> TestSubscriber<Integer> ts = BehaviorProcessor.createDefault(1)
<add> .window(f1, v -> f2)
<add> .flatMap(v -> v)
<add> .test();
<add>
<add> ref1.get().onSubscribe(new BooleanSubscription());
<add> ref1.get().onNext(1);
<add> ref2.get().onSubscribe(new BooleanSubscription());
<add>
<add> ref2.get().onError(new TestException());
<add> ref2.get().onError(new TestException());
<add>
<add> ts.assertFailure(TestException.class);
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> });
<add> }
<add>
<add> @Test
<add> public void upstreamFailsBeforeFirstWindow() {
<add> Flowable.error(new TestException())
<add> .window(Flowable.never(), v -> Flowable.never())
<add> .test()
<add> .assertFailure(TestException.class);
<add> }
<add>
<add> @Test
<add> public void windowOpenMainCompletes() {
<add> AtomicReference<Subscriber<? super Integer>> ref1 = new AtomicReference<>();
<add>
<add> PublishProcessor<Object> pp = PublishProcessor.create();
<add> Flowable<Integer> f1 = Flowable.<Integer>unsafeCreate(ref1::set);
<add>
<add> AtomicInteger counter = new AtomicInteger();
<add>
<add> TestSubscriber<Flowable<Object>> ts = pp
<add> .window(f1, v -> Flowable.never())
<add> .doOnNext(w -> {
<add> if (counter.getAndIncrement() == 0) {
<add> ref1.get().onNext(2);
<add> pp.onNext(1);
<add> pp.onComplete();
<add> }
<add> w.test();
<add> })
<add> .test();
<add>
<add> ref1.get().onSubscribe(new BooleanSubscription());
<add> ref1.get().onNext(1);
<add>
<add> ts.assertComplete();
<add> }
<add>
<add> @Test
<add> public void windowOpenMainError() {
<add> AtomicReference<Subscriber<? super Integer>> ref1 = new AtomicReference<>();
<add>
<add> PublishProcessor<Object> pp = PublishProcessor.create();
<add> Flowable<Integer> f1 = Flowable.<Integer>unsafeCreate(ref1::set);
<add>
<add> AtomicInteger counter = new AtomicInteger();
<add>
<add> TestSubscriber<Flowable<Object>> ts = pp
<add> .window(f1, v -> Flowable.never())
<add> .doOnNext(w -> {
<add> if (counter.getAndIncrement() == 0) {
<add> ref1.get().onNext(2);
<add> pp.onNext(1);
<add> pp.onError(new TestException());
<add> }
<add> w.test();
<add> })
<add> .test();
<add>
<add> ref1.get().onSubscribe(new BooleanSubscription());
<add> ref1.get().onNext(1);
<add>
<add> ts.assertError(TestException.class);
<add> }
<add>
<add> @Test
<add> public void windowOpenIgnoresDispose() {
<add> AtomicReference<Subscriber<? super Integer>> ref1 = new AtomicReference<>();
<add>
<add> PublishProcessor<Object> pp = PublishProcessor.create();
<add> Flowable<Integer> f1 = Flowable.<Integer>unsafeCreate(ref1::set);
<add>
<add> TestSubscriber<Flowable<Object>> ts = pp
<add> .window(f1, v -> Flowable.never())
<add> .take(1)
<add> .doOnNext(w -> {
<add> w.test();
<add> })
<add> .test();
<add>
<add> ref1.get().onSubscribe(new BooleanSubscription());
<add> ref1.get().onNext(1);
<add> ref1.get().onNext(2);
<add>
<add> ts.assertValueCount(1);
<add> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().window(Flowable.never(), v -> Flowable.never()));
<add> }
<add>
<add> @Test
<add> public void mainIgnoresCancelBeforeOnError() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> Flowable.fromPublisher(s -> {
<add> s.onSubscribe(new BooleanSubscription());
<add> s.onNext(1);
<add> s.onError(new IOException());
<add> })
<add> .window(BehaviorProcessor.createDefault(1), v -> Flowable.error(new TestException()))
<add> .doOnNext(w -> w.test())
<add> .test()
<add> .assertError(TestException.class);
<add>
<add> TestHelper.assertUndeliverable(errors, 0, IOException.class);
<add> });
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableWindowWithTimeTest.java
<ide> public void accept(Flowable<Integer> v) throws Throwable {
<ide>
<ide> inner.get().test().assertResult();
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Flowable.never().window(1, TimeUnit.SECONDS));
<add> }
<add>
<add> @Test
<add> public void timedBoundarySignalAndDisposeRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> TestScheduler scheduler = new TestScheduler();
<add>
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Flowable<Integer>> ts = pp.window(1, TimeUnit.MINUTES, scheduler, 1)
<add> .test();
<add>
<add> TestHelper.race(
<add> () -> pp.onNext(1),
<add> () -> ts.cancel()
<add> );
<add> }
<add> }
<ide> }
<ide>
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableZipTest.java
<ide> public Integer apply(Object[] t) throws Throwable {
<ide> .test()
<ide> .assertResult(2);
<ide> }
<add>
<add> @Test
<add> public void fusedInnerPollCrashDelayError() {
<add> Flowable.zip(
<add> Flowable.range(1, 5),
<add> Flowable.just(1)
<add> .<Integer>map(v -> { throw new TestException(); })
<add> .compose(TestHelper.flowableStripBoundary()),
<add> (a, b) -> a + b, true
<add> )
<add> .test()
<add> .assertFailure(TestException.class);
<add> }
<add>
<add> @Test
<add> public void fusedInnerPollCrashRequestBoundaryDelayError() {
<add> Flowable.zip(
<add> Flowable.range(1, 5),
<add> Flowable.just(1)
<add> .<Integer>map(v -> { throw new TestException(); })
<add> .compose(TestHelper.flowableStripBoundary()),
<add> (a, b) -> a + b, true
<add> )
<add> .test(0L)
<add> .assertFailure(TestException.class);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeConcatArrayTest.java
<ide> import java.io.IOException;
<ide> import java.util.List;
<ide>
<del>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import org.junit.Test;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<add>import io.reactivex.rxjava3.subjects.MaybeSubject;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public void subscribe(MaybeEmitter<Integer> s) throws Exception {
<ide>
<ide> assertEquals(1, calls[0]);
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Maybe.concatArray(MaybeSubject.create(), MaybeSubject.create()));
<add> }
<add>
<add> @Test
<add> public void badRequestDelayError() {
<add> TestHelper.assertBadRequestReported(Maybe.concatArrayDelayError(MaybeSubject.create(), MaybeSubject.create()));
<add> }
<add>
<add> @Test
<add> public void mixed() {
<add> Maybe.concatArray(
<add> Maybe.just(1),
<add> Maybe.empty(),
<add> Maybe.just(2),
<add> Maybe.empty(),
<add> Maybe.empty()
<add> )
<add> .test()
<add> .assertResult(1, 2);
<add> }
<add>
<add> @Test
<add> public void requestBeforeSuccess() {
<add> MaybeSubject<Integer> ms = MaybeSubject.create();
<add> TestSubscriber<Integer> ts = Maybe.concatArray(ms, ms)
<add> .test();
<add>
<add> ts.assertEmpty();
<add>
<add> ms.onSuccess(1);
<add>
<add> ts.assertResult(1, 1);
<add> }
<add>
<add> @Test
<add> public void requestBeforeComplete() {
<add> MaybeSubject<Integer> ms = MaybeSubject.create();
<add> TestSubscriber<Integer> ts = Maybe.concatArray(ms, ms)
<add> .test();
<add>
<add> ts.assertEmpty();
<add>
<add> ms.onComplete();
<add>
<add> ts.assertResult();
<add> }
<add>
<add> @Test
<add> public void requestBeforeSuccessDelayError() {
<add> MaybeSubject<Integer> ms = MaybeSubject.create();
<add> TestSubscriber<Integer> ts = Maybe.concatArrayDelayError(ms, ms)
<add> .test();
<add>
<add> ts.assertEmpty();
<add>
<add> ms.onSuccess(1);
<add>
<add> ts.assertResult(1, 1);
<add> }
<add>
<add> @Test
<add> public void requestBeforeCompleteDelayError() {
<add> MaybeSubject<Integer> ms = MaybeSubject.create();
<add> TestSubscriber<Integer> ts = Maybe.concatArrayDelayError(ms, ms)
<add> .test();
<add>
<add> ts.assertEmpty();
<add>
<add> ms.onComplete();
<add>
<add> ts.assertResult();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeConcatIterableTest.java
<ide> import io.reactivex.rxjava3.functions.Function;
<ide> import io.reactivex.rxjava3.internal.util.CrashingMappedIterable;
<ide> import io.reactivex.rxjava3.processors.PublishProcessor;
<add>import io.reactivex.rxjava3.subjects.MaybeSubject;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public void subscribe(MaybeEmitter<Integer> s) throws Exception {
<ide>
<ide> assertEquals(1, calls[0]);
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(Maybe.concat(Arrays.asList(
<add> MaybeSubject.create(),
<add> MaybeSubject.create()
<add> )));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeDelaySubscriptionTest.java
<ide> protected void subscribeActual(Subscriber<? super Integer> subscriber) {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribePublisher() {
<add> TestHelper.checkDoubleOnSubscribeFlowableToMaybe(f -> Maybe.just(1).delaySubscription(f));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeFlatMapIterableFlowableTest.java
<ide> import io.reactivex.rxjava3.internal.fuseable.*;
<ide> import io.reactivex.rxjava3.internal.util.CrashingIterable;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<del>import io.reactivex.rxjava3.subjects.PublishSubject;
<add>import io.reactivex.rxjava3.subjects.*;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public Iterable<Integer> apply(Integer v) throws Exception {
<ide> .assertResult(1);
<ide> }
<ide>
<add> @Test
<add> public void take2() {
<add> Maybe.just(1).flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
<add> @Override
<add> public Iterable<Integer> apply(Integer v) throws Exception {
<add> return Arrays.asList(v, v + 1);
<add> }
<add> })
<add> .doOnSubscribe(s -> s.request(Long.MAX_VALUE))
<add> .take(1)
<add> .test()
<add> .assertResult(1);
<add> }
<add>
<ide> @Test
<ide> public void fused() {
<ide> TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.ANY);
<ide> public void remove() {
<ide> ts.request(Long.MAX_VALUE);
<ide> ts.assertValues(1, 1).assertNoErrors().assertNotComplete();
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(MaybeSubject.create().flattenAsFlowable(v -> Arrays.asList(v)));
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeMaybeToFlowable(m -> m.flattenAsFlowable(v -> Arrays.asList(v)));
<add> }
<add>
<add> @Test
<add> public void onSuccessRequestRace() {
<add> List<Object> list = Arrays.asList(1);
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add>
<add> MaybeSubject<Integer> ms = MaybeSubject.create();
<add>
<add> TestSubscriber<Object> ts = ms.flattenAsFlowable(v -> list)
<add> .test(0L);
<add>
<add> TestHelper.race(
<add> () -> ms.onSuccess(1),
<add> () -> ts.request(1)
<add> );
<add>
<add> ts.assertResult(1);
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeFromCallableTest.java
<ide> public String answer(InvocationOnMock invocation) throws Throwable {
<ide> verify(observer).onSubscribe(any(Disposable.class));
<ide> verifyNoMoreInteractions(observer);
<ide> }
<add>
<add> @Test
<add> public void disposeUpfront() {
<add> Maybe.fromCallable(() -> 1)
<add> .test(true)
<add> .assertEmpty();
<add> }
<add>
<add> @Test
<add> public void success() {
<add> Maybe.fromCallable(() -> 1)
<add> .test()
<add> .assertResult(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeFromSupplierTest.java
<ide> public String answer(InvocationOnMock invocation) throws Throwable {
<ide> verify(observer).onSubscribe(any(Disposable.class));
<ide> verifyNoMoreInteractions(observer);
<ide> }
<add>
<add> @Test
<add> public void success() {
<add> Maybe.fromSupplier(() -> 1)
<add> .test()
<add> .assertResult(1);
<add> }
<add>
<add> @Test
<add> public void disposeUpfront() throws Throwable {
<add> @SuppressWarnings("unchecked")
<add> Supplier<Integer> supplier = mock(Supplier.class);
<add>
<add> Maybe.fromSupplier(supplier)
<add> .test(true)
<add> .assertEmpty();
<add>
<add> verify(supplier, never()).get();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeMergeArrayTest.java
<ide>
<ide> import java.util.*;
<ide>
<del>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import org.junit.Test;
<ide> import org.reactivestreams.Subscription;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.internal.fuseable.*;
<ide> import io.reactivex.rxjava3.internal.operators.maybe.MaybeMergeArray.MergeMaybeObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<del>import io.reactivex.rxjava3.subjects.PublishSubject;
<add>import io.reactivex.rxjava3.subjects.*;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public void onComplete() {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(
<add> Maybe.mergeArray(MaybeSubject.create(), MaybeSubject.create())
<add> );
<add> }
<add>
<add> @Test
<add> public void cancel2() {
<add> TestHelper.checkDisposed(Maybe.mergeArray(MaybeSubject.create(), MaybeSubject.create()));
<add> }
<add>
<add> @Test
<add> public void take() {
<add> Maybe.mergeArray(Maybe.just(1), Maybe.empty(), Maybe.just(2))
<add> .doOnSubscribe(s -> s.request(Long.MAX_VALUE))
<add> .take(1)
<add> .test()
<add> .assertResult(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeTimeoutPublisherTest.java
<ide>
<ide> import org.junit.Test;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.Function;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> public Object apply(Flowable<Integer> f) throws Exception {
<ide> }
<ide> }, false, null, 1, 1);
<ide> }
<add>
<add> @Test
<add> public void mainSuccessAfterOtherSignal() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> new Maybe<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull MaybeObserver<? super Integer> observer) {
<add> observer.onSubscribe(Disposable.empty());
<add> pp.onNext(2);
<add> observer.onSuccess(1);
<add> }
<add> }
<add> .timeout(pp)
<add> .test()
<add> .assertFailure(TimeoutException.class);
<add> }
<add>
<add> @Test
<add> public void mainSuccess() {
<add> Maybe.just(1)
<add> .timeout(Flowable.never())
<add> .test()
<add> .assertResult(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeTimeoutTest.java
<ide>
<ide> import org.junit.Test;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.PublishProcessor;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<add>import io.reactivex.rxjava3.subjects.MaybeSubject;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public class MaybeTimeoutTest extends RxJavaTest {
<ide> public void run() {
<ide> }
<ide> }
<ide> }
<add>
<add> @Test
<add> public void mainSuccessAfterOtherSignal() {
<add> MaybeSubject<Integer> ms = MaybeSubject.create();
<add>
<add> new Maybe<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull MaybeObserver<? super Integer> observer) {
<add> observer.onSubscribe(Disposable.empty());
<add> ms.onSuccess(2);
<add> observer.onSuccess(1);
<add> }
<add> }
<add> .timeout(ms)
<add> .test()
<add> .assertFailure(TimeoutException.class);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeZipArrayTest.java
<ide>
<ide> import static org.junit.Assert.*;
<ide>
<del>import java.util.List;
<add>import java.util.*;
<add>import java.util.concurrent.atomic.AtomicReference;
<ide>
<ide> import org.junit.Test;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.PublishProcessor;
<add>import io.reactivex.rxjava3.subjects.MaybeSubject;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public class MaybeZipArrayTest extends RxJavaTest {
<ide> public void singleSourceZipperReturnsNull() {
<ide> .to(TestHelper.<Object>testConsumer())
<ide> .assertFailureAndMessage(NullPointerException.class, "The zipper returned a null value");
<ide> }
<add>
<add> @Test
<add> public void dispose2() {
<add> TestHelper.checkDisposed(Maybe.zipArray(v -> v, MaybeSubject.create(), MaybeSubject.create()));
<add> }
<add>
<add> @Test
<add> public void bothComplete() {
<add> AtomicReference<MaybeObserver<? super Integer>> ref1 = new AtomicReference<>();
<add> AtomicReference<MaybeObserver<? super Integer>> ref2 = new AtomicReference<>();
<add>
<add> Maybe<Integer> m1 = new Maybe<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull MaybeObserver<? super Integer> observer) {
<add> ref1.set(observer);
<add> }
<add> };
<add> Maybe<Integer> m2 = new Maybe<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull MaybeObserver<? super Integer> observer) {
<add> ref2.set(observer);
<add> }
<add> };
<add>
<add> TestObserver<Object[]> to = Maybe.zipArray(v -> v, m1, m2)
<add> .test();
<add>
<add> ref1.get().onSubscribe(Disposable.empty());
<add> ref2.get().onSubscribe(Disposable.empty());
<add>
<add> ref1.get().onComplete();
<add> ref2.get().onComplete();
<add>
<add> to.assertResult();
<add> }
<add>
<add> @Test
<add> public void bothSucceed() {
<add> Maybe.zipArray(v -> Arrays.asList(v), Maybe.just(1), Maybe.just(2))
<add> .test()
<add> .assertResult(Arrays.asList(1, 2));
<add> }
<add>
<add> @Test
<add> public void oneSourceOnly() {
<add> Maybe.zipArray(v -> Arrays.asList(v), Maybe.just(1))
<add> .test()
<add> .assertResult(Arrays.asList(1));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/BlockingObservableToIteratorTest.java
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.core.Observable;
<ide> import io.reactivex.rxjava3.core.Observer;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.internal.operators.observable.BlockingObservableIterable.BlockingObservableIterator;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> public void run() {
<ide>
<ide> assertFalse(it.hasNext());
<ide> }
<add>
<add> @Test(expected = TestException.class)
<add> public void errorAfterDispose() {
<add> Iterator<Object> it = Observable.error(new TestException()).blockingIterable().iterator();
<add>
<add> ((Disposable)it).dispose();
<add>
<add> it.hasNext();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableAllTest.java
<ide> public boolean test(Integer v) throws Exception {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeObservableToSingle(o -> o.all(v -> true));
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribeObservable() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.all(v -> true).toObservable());
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableBufferTest.java
<ide> import io.reactivex.rxjava3.observers.*;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.schedulers.*;
<del>import io.reactivex.rxjava3.subjects.PublishSubject;
<add>import io.reactivex.rxjava3.subjects.*;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public class ObservableBufferTest extends RxJavaTest {
<ide> public List<Object> get() throws Exception {
<ide> .assertFailure(TestException.class)
<ide> ;
<ide> }
<add>
<add> @Test
<add> public void timedUnboundedCancelUpfront() {
<add> Observable.never()
<add> .buffer(1, TimeUnit.SECONDS)
<add> .test(true)
<add> .assertEmpty();
<add> }
<add>
<add> @Test
<add> public void boundaryCloseCompleteRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> BehaviorSubject<Integer> bs = BehaviorSubject.createDefault(1);
<add> PublishSubject<Integer> ps = PublishSubject.create();
<add>
<add> TestObserver<List<Integer>> to = bs
<add> .buffer(BehaviorSubject.createDefault(0), v -> ps)
<add> .test();
<add>
<add> TestHelper.race(
<add> () -> bs.onComplete(),
<add> () -> ps.onComplete()
<add> );
<add>
<add> to.assertResult(Arrays.asList(1));
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableCacheTest.java
<ide> import java.util.concurrent.*;
<ide> import java.util.concurrent.atomic.AtomicInteger;
<ide>
<del>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import org.junit.Test;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.core.Observable;
<ide> import io.reactivex.rxjava3.core.Observer;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> public Object call() throws Exception {
<ide>
<ide> assertEquals(1, call.get());
<ide> }
<add>
<add> @Test
<add> public void addRemoveRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> Observable<Object> o = Observable.never().cache();
<add>
<add> TestObserver<Object> to = o.test();
<add>
<add> TestHelper.race(
<add> () -> to.dispose(),
<add> () -> o.test()
<add> );
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableCombineLatestTest.java
<ide>
<ide> import java.util.*;
<ide> import java.util.concurrent.*;
<del>import java.util.concurrent.atomic.AtomicInteger;
<add>import java.util.concurrent.atomic.*;
<ide>
<ide> import org.junit.Test;
<ide> import org.mockito.*;
<ide> public Integer apply(Object[] t) throws Throwable {
<ide> .test()
<ide> .assertResult(2);
<ide> }
<add>
<add> @Test
<add> public void onCompleteDisposeRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add>
<add> TestObserver<Integer> to = new TestObserver<>();
<add> PublishSubject<Integer> ps = PublishSubject.create();
<add>
<add> Observable.combineLatest(ps, Observable.never(), (a, b) -> a)
<add> .subscribe(to);
<add>
<add> TestHelper.race(() -> ps.onComplete(), () -> to.dispose());
<add> }
<add> }
<add>
<add> @Test
<add> public void onErrorDisposeDelayErrorRace() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> TestException ex = new TestException();
<add>
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add>
<add> TestObserverEx<Object[]> to = new TestObserverEx<>();
<add> AtomicReference<Observer<? super Object>> ref = new AtomicReference<>();
<add> Observable<Object> o = new Observable<Object>() {
<add> @Override
<add> public void subscribeActual(Observer<? super Object> observer) {
<add> ref.set(observer);
<add> }
<add> };
<add>
<add> Observable.combineLatestDelayError(Arrays.asList(o, Observable.never()), (a) -> a)
<add> .subscribe(to);
<add>
<add> ref.get().onSubscribe(Disposable.empty());
<add>
<add> TestHelper.race(() -> ref.get().onError(ex), () -> to.dispose());
<add>
<add> if (to.errors().isEmpty()) {
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> }
<add> }
<add> });
<add> }
<add>
<add> @Test
<add> public void doneButNotEmpty() {
<add> PublishSubject<Integer> ps1 = PublishSubject.create();
<add> PublishSubject<Integer> ps2 = PublishSubject.create();
<add>
<add> TestObserver<Integer> to = Observable.combineLatest(ps1, ps2, (a, b) -> a + b)
<add> .doOnNext(v -> {
<add> if (v == 2) {
<add> ps2.onNext(3);
<add> ps2.onComplete();
<add> ps1.onComplete();
<add> }
<add> })
<add> .test();
<add>
<add> ps1.onNext(1);
<add> ps2.onNext(1);
<add>
<add> to.assertResult(2, 4);
<add> }
<add>
<add> @Test
<add> public void iterableNullPublisher() {
<add> Observable.combineLatest(Arrays.asList(Observable.never(), null), (a) -> a)
<add> .test()
<add> .assertFailure(NullPointerException.class);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableConcatMapEagerTest.java
<ide> public void observerDelayErrorMaxConcurrency() {
<ide> .test()
<ide> .assertFailure(TestException.class, 1, 2, 3, 4, 5);
<ide> }
<add>
<add> @Test
<add> public void innerFusionRejected() {
<add> Observable.just(1)
<add> .hide()
<add> .concatMapEager(v -> TestHelper.rejectObservableFusion())
<add> .test()
<add> .assertEmpty();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableConcatMapSchedulerTest.java
<ide> import java.util.concurrent.*;
<ide> import java.util.concurrent.atomic.AtomicInteger;
<ide>
<del>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import org.junit.Test;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.core.Observable;
<ide> import io.reactivex.rxjava3.core.Observer;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.*;
<add>import io.reactivex.rxjava3.internal.disposables.EmptyDisposable;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.schedulers.ImmediateThinScheduler;
<ide> import io.reactivex.rxjava3.observers.*;
<ide> public Observable<Integer> apply(Integer v) throws Throwable {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void fusionRejected() {
<add> TestObserverEx<Object> to = new TestObserverEx<>();
<add>
<add> TestHelper.rejectObservableFusion()
<add> .concatMap(v -> Observable.never(), 2, ImmediateThinScheduler.INSTANCE)
<add> .subscribe(to);
<add> }
<add>
<add> @Test
<add> public void fusionRejectedDelayErrorr() {
<add> TestObserverEx<Object> to = new TestObserverEx<>();
<add>
<add> TestHelper.rejectObservableFusion()
<add> .concatMapDelayError(v -> Observable.never(), true, 2, ImmediateThinScheduler.INSTANCE)
<add> .subscribe(to);
<add> }
<add>
<add> @Test
<add> public void scalarInnerJustDisposeDelayError() {
<add> TestObserver<Integer> to = new TestObserver<>();
<add>
<add> Observable.just(1)
<add> .hide()
<add> .concatMapDelayError(v -> Observable.fromCallable(() -> {
<add> to.dispose();
<add> return 1;
<add> }), true, 2, ImmediateThinScheduler.INSTANCE)
<add> .subscribe(to);
<add>
<add> to.assertEmpty();
<add> }
<add>
<add> static final class EmptyDisposingObservable extends Observable<Object>
<add> implements Supplier<Object> {
<add> final TestObserver<Object> to;
<add> EmptyDisposingObservable(TestObserver<Object> to) {
<add> this.to = to;
<add> }
<add>
<add> @Override
<add> protected void subscribeActual(@NonNull Observer<? super @NonNull Object> observer) {
<add> EmptyDisposable.complete(observer);
<add> }
<add>
<add> @Override
<add> public @NonNull Object get() throws Throwable {
<add> to.dispose();
<add> return null;
<add> }
<add> }
<add>
<add> @Test
<add> public void scalarInnerEmptyDisposeDelayError() {
<add> TestObserver<Object> to = new TestObserver<>();
<add>
<add> Observable.just(1)
<add> .hide()
<add> .concatMapDelayError(v -> new EmptyDisposingObservable(to),
<add> true, 2, ImmediateThinScheduler.INSTANCE
<add> )
<add> .subscribe(to);
<add>
<add> to.assertEmpty();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableConcatMapTest.java
<ide> import org.junit.Test;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<add>import io.reactivex.rxjava3.internal.operators.observable.ObservableConcatMapSchedulerTest.EmptyDisposingObservable;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.subjects.*;
<ide> public Observable<Integer> apply(Integer v) throws Throwable {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.concatMap(v -> Observable.never()));
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribeDelayError() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.concatMapDelayError(v -> Observable.never()));
<add> }
<add>
<add> @Test
<add> public void scalarXMap() {
<add> Observable.fromCallable(() -> 1)
<add> .concatMap(v -> Observable.just(2).hide())
<add> .test()
<add> .assertResult(2);
<add> }
<add>
<add> @Test
<add> public void rejectedFusion() {
<add> TestHelper.rejectObservableFusion()
<add> .concatMap(v -> Observable.never())
<add> .test();
<add> }
<add>
<add> @Test
<add> public void rejectedFusionDelayError() {
<add> TestHelper.rejectObservableFusion()
<add> .concatMapDelayError(v -> Observable.never())
<add> .test();
<add> }
<add>
<add> @Test
<add> public void asyncFusedDelayError() {
<add> UnicastSubject<Integer> uc = UnicastSubject.create();
<add>
<add> TestObserver<Integer> to = uc.concatMapDelayError(v -> Observable.just(v).hide())
<add> .test();
<add>
<add> uc.onNext(1);
<add> uc.onComplete();
<add>
<add> to.assertResult(1);
<add> }
<add>
<add> @Test
<add> public void scalarInnerJustDelayError() {
<add> Observable.just(1)
<add> .hide()
<add> .concatMapDelayError(v -> Observable.just(v))
<add> .test()
<add> .assertResult(1);
<add> }
<add>
<add> @Test
<add> public void scalarInnerEmptyDelayError() {
<add> Observable.just(1)
<add> .hide()
<add> .concatMapDelayError(v -> Observable.empty())
<add> .test()
<add> .assertResult();
<add> }
<add>
<add> @Test
<add> public void scalarInnerJustDisposeDelayError() {
<add> TestObserver<Integer> to = new TestObserver<>();
<add>
<add> Observable.just(1)
<add> .hide()
<add> .concatMapDelayError(v -> Observable.fromCallable(() -> {
<add> to.dispose();
<add> return 1;
<add> }))
<add> .subscribe(to);
<add>
<add> to.assertEmpty();
<add> }
<add>
<add> @Test
<add> public void scalarInnerEmptyDisposeDelayError() {
<add> TestObserver<Object> to = new TestObserver<>();
<add>
<add> Observable.just(1)
<add> .hide()
<add> .concatMapDelayError(v -> new EmptyDisposingObservable(to))
<add> .subscribe(to);
<add>
<add> to.assertEmpty();
<add> }
<add>
<add> @Test
<add> public void delayErrorInnerActive() {
<add> PublishSubject<Integer> ps = PublishSubject.create();
<add>
<add> TestObserver<Integer> to = Observable.range(1, 5)
<add> .hide()
<add> .concatMapDelayError(v -> ps)
<add> .test();
<add>
<add> ps.onComplete();
<add>
<add> to.assertResult();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableCreateTest.java
<ide>
<ide> import java.io.IOException;
<ide> import java.util.List;
<add>import java.util.concurrent.CountDownLatch;
<add>import java.util.concurrent.atomic.AtomicReference;
<ide>
<ide> import org.junit.Test;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.Cancellable;
<add>import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
<ide> }
<ide> }).test().assertEmpty();
<ide> }
<add>
<add> @Test
<add> public void emptySerialized() {
<add> Observable.create(emitter -> emitter.serialize().onComplete())
<add> .test()
<add> .assertResult();
<add> }
<add>
<add> @Test
<add> public void serializedDisposedBeforeOnNext() {
<add> TestObserver<Object> to = new TestObserver<>();
<add>
<add> Observable.create(emitter -> {
<add> to.dispose();
<add> emitter.serialize().onNext(1);
<add> })
<add> .subscribe(to);
<add>
<add> to.assertEmpty();
<add> }
<add>
<add> @Test
<add> public void serializedOnNextAfterComplete() {
<add> TestObserver<Object> to = new TestObserver<>();
<add>
<add> Observable.create(emitter -> {
<add> emitter = emitter.serialize();
<add>
<add> emitter.onComplete();
<add> emitter.onNext(1);
<add> })
<add> .subscribe(to);
<add>
<add> to.assertResult();
<add> }
<add>
<add> @Test
<add> public void serializedEnqueueAndDrainRace() throws Throwable {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> TestObserver<Integer> to = new TestObserver<>();
<add> AtomicReference<ObservableEmitter<Integer>> ref = new AtomicReference<>();
<add>
<add> CountDownLatch cdl = new CountDownLatch(1);
<add>
<add> Observable.<Integer>create(emitter -> {
<add> emitter = emitter.serialize();
<add> ref.set(emitter);
<add> emitter.onNext(1);
<add> })
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> TestHelper.raceOther(() -> {
<add> ref.get().onNext(2);
<add> }, cdl);
<add> ref.get().onNext(3);
<add> }
<add> })
<add> .subscribe(to);
<add>
<add> cdl.await();
<add>
<add> to.assertValueCount(3);
<add> }
<add> }
<add>
<add> @Test
<add> public void serializedDrainDoneButNotEmpty() throws Throwable {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> TestObserver<Integer> to = new TestObserver<>();
<add> AtomicReference<ObservableEmitter<Integer>> ref = new AtomicReference<>();
<add>
<add> CountDownLatch cdl = new CountDownLatch(1);
<add>
<add> Observable.<Integer>create(emitter -> {
<add> emitter = emitter.serialize();
<add> ref.set(emitter);
<add> emitter.onNext(1);
<add> })
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> TestHelper.raceOther(() -> {
<add> ref.get().onNext(2);
<add> ref.get().onComplete();
<add> }, cdl);
<add> ref.get().onNext(3);
<add> }
<add> })
<add> .subscribe(to);
<add>
<add> cdl.await();
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableDebounceTest.java
<ide> public ObservableSource<Object> apply(Object o) {
<ide> }
<ide> }).subscribe();
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribeTime() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.debounce(1, TimeUnit.SECONDS));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableDematerializeTest.java
<ide> protected void subscribeActual(Observer<? super Notification<Object>> observer)
<ide> }
<ide>
<ide> @Test
<add> @SuppressWarnings("unchecked")
<ide> public void nonNotificationInstanceAfterDispose() {
<del> new Observable<Notification<Object>>() {
<add> new Observable<Object>() {
<ide> @Override
<del> protected void subscribeActual(Observer<? super Notification<Object>> observer) {
<add> protected void subscribeActual(Observer<? super Object> observer) {
<ide> observer.onSubscribe(Disposable.empty());
<ide> observer.onNext(Notification.createOnComplete());
<del> observer.onNext(Notification.<Object>createOnNext(1));
<add> observer.onNext(1);
<ide> }
<ide> }
<del> .dematerialize(Functions.<Notification<Object>>identity())
<add> .dematerialize(v -> (Notification<Object>)v)
<ide> .test()
<ide> .assertResult();
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableDoFinallyTest.java
<ide> public void run() throws Exception {
<ide> assertEquals(Arrays.asList("onNext", "onComplete", "finally"), list);
<ide> }
<ide>
<add> @Test
<add> public void fusionRejected() {
<add> TestObserverEx<Object> to = new TestObserverEx<>();
<add> to.setInitialFusionMode(QueueFuseable.ANY);
<add>
<add> TestHelper.rejectObservableFusion()
<add> .doFinally(() -> { })
<add> .subscribeWith(to);
<add>
<add> to.assertFuseable()
<add> .assertFusionMode(QueueFuseable.NONE);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFlatMapCompletableTest.java
<ide> import static org.junit.Assert.*;
<ide>
<ide> import java.util.List;
<del>import java.util.concurrent.TimeUnit;
<add>import java.util.concurrent.*;
<ide>
<ide> import org.junit.Test;
<ide>
<ide> public Completable apply(Integer v) throws Throwable {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.flatMapCompletable(v -> Completable.never()).toObservable());
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribeCompletable() {
<add> TestHelper.checkDoubleOnSubscribeObservableToCompletable(o -> o.flatMapCompletable(v -> Completable.never()));
<add> }
<add>
<add> @Test
<add> public void cancelWhileMapping() throws Throwable {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> PublishSubject<Integer> ps1 = PublishSubject.create();
<add>
<add> TestObserver<Object> to = new TestObserver<>();
<add> CountDownLatch cdl = new CountDownLatch(1);
<add>
<add> ps1.flatMapCompletable(v -> {
<add> TestHelper.raceOther(() -> {
<add> to.dispose();
<add> }, cdl);
<add> return Completable.complete();
<add> })
<add> .toObservable()
<add> .subscribe(to);
<add>
<add> ps1.onNext(1);
<add>
<add> cdl.await();
<add> }
<add> }
<add>
<add> @Test
<add> public void cancelWhileMappingCompletable() throws Throwable {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> PublishSubject<Integer> ps1 = PublishSubject.create();
<add>
<add> TestObserver<Void> to = new TestObserver<>();
<add> CountDownLatch cdl = new CountDownLatch(1);
<add>
<add> ps1.flatMapCompletable(v -> {
<add> TestHelper.raceOther(() -> {
<add> to.dispose();
<add> }, cdl);
<add> return Completable.complete();
<add> })
<add> .subscribe(to);
<add>
<add> ps1.onNext(1);
<add>
<add> cdl.await();
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFlatMapMaybeTest.java
<ide> import org.junit.Test;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.Function;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<del>import io.reactivex.rxjava3.subjects.PublishSubject;
<add>import io.reactivex.rxjava3.subjects.*;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public class ObservableFlatMapMaybeTest extends RxJavaTest {
<ide> public Maybe<Integer> apply(Integer v) throws Throwable {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void cancelWhileMapping() throws Throwable {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> PublishSubject<Integer> ps1 = PublishSubject.create();
<add>
<add> TestObserver<Integer> to = new TestObserver<>();
<add> CountDownLatch cdl = new CountDownLatch(1);
<add>
<add> ps1.flatMapMaybe(v -> {
<add> TestHelper.raceOther(() -> {
<add> to.dispose();
<add> }, cdl);
<add> return Maybe.just(1);
<add> })
<add> .subscribe(to);
<add>
<add> ps1.onNext(1);
<add>
<add> cdl.await();
<add> }
<add> }
<add>
<add> @Test
<add> public void successCompleteRace() {
<add> for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
<add> MaybeSubject<Integer> ms1 = MaybeSubject.create();
<add> MaybeSubject<Integer> ms2 = MaybeSubject.create();
<add>
<add> TestObserver<Integer> to = Observable.just(1, 2)
<add> .flatMapMaybe(v -> v == 1 ? ms1 : ms2)
<add> .test();
<add>
<add> TestHelper.race(
<add> () -> ms1.onComplete(),
<add> () -> ms2.onSuccess(1)
<add> );
<add>
<add> to.assertResult(1);
<add> }
<add> }
<add>
<add> @Test
<add> public void successCompleteRace2() {
<add> for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
<add> MaybeSubject<Integer> ms1 = MaybeSubject.create();
<add> MaybeSubject<Integer> ms2 = MaybeSubject.create();
<add>
<add> TestObserver<Integer> to = Observable.just(1, 2)
<add> .flatMapMaybe(v -> v == 1 ? ms1 : ms2)
<add> .test();
<add>
<add> TestHelper.race(
<add> () -> ms2.onSuccess(1),
<add> () -> ms1.onComplete()
<add> );
<add>
<add> to.assertResult(1);
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFlatMapSingleTest.java
<ide> import org.junit.Test;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.Function;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<del>import io.reactivex.rxjava3.subjects.PublishSubject;
<add>import io.reactivex.rxjava3.subjects.*;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public class ObservableFlatMapSingleTest extends RxJavaTest {
<ide> public Single<Integer> apply(Integer v) throws Throwable {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void innerErrorOuterCompleteRace() {
<add> TestException ex = new TestException();
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> PublishSubject<Integer> ps1 = PublishSubject.create();
<add> SingleSubject<Integer> ps2 = SingleSubject.create();
<add>
<add> TestObserver<Integer> to = ps1.flatMapSingle(v -> ps2)
<add> .test();
<add>
<add> ps1.onNext(1);
<add>
<add> TestHelper.race(
<add> () -> ps1.onComplete(),
<add> () -> ps2.onError(ex)
<add> );
<add>
<add> to.assertFailure(TestException.class);
<add> }
<add> }
<add>
<add> @Test
<add> public void cancelWhileMapping() throws Throwable {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> PublishSubject<Integer> ps1 = PublishSubject.create();
<add>
<add> TestObserver<Integer> to = new TestObserver<>();
<add> CountDownLatch cdl = new CountDownLatch(1);
<add>
<add> ps1.flatMapSingle(v -> {
<add> TestHelper.raceOther(() -> {
<add> to.dispose();
<add> }, cdl);
<add> return Single.just(1);
<add> })
<add> .subscribe(to);
<add>
<add> ps1.onNext(1);
<add>
<add> cdl.await();
<add> }
<add> }
<add>
<add> @Test
<add> public void onNextDrainCancel() {
<add> SingleSubject<Integer> ss1 = SingleSubject.create();
<add> SingleSubject<Integer> ss2 = SingleSubject.create();
<add>
<add> TestObserver<Integer> to = new TestObserver<>();
<add>
<add> Observable.just(1, 2)
<add> .flatMapSingle(v -> v == 1 ? ss1 : ss2)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> ss2.onSuccess(2);
<add> to.dispose();
<add> }
<add> })
<add> .subscribe(to);
<add>
<add> ss1.onSuccess(1);
<add>
<add> to.assertValuesOnly(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFlatMapTest.java
<ide> import static org.mockito.ArgumentMatchers.any;
<ide> import static org.mockito.Mockito.*;
<ide>
<add>import java.io.IOException;
<ide> import java.util.*;
<ide> import java.util.concurrent.*;
<ide> import java.util.concurrent.atomic.AtomicInteger;
<ide>
<ide> import org.junit.*;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.core.Observable;
<ide> import io.reactivex.rxjava3.core.Observer;
<ide> public void innerErrorsMainCancelled() {
<ide>
<ide> assertFalse("Has subscribers?", ps1.hasObservers());
<ide> }
<add>
<add> @Test
<add> public void signalsAfterMapperCrash() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> new Observable<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull Observer<? super @NonNull Integer> observer) {
<add> observer.onSubscribe(Disposable.empty());
<add> observer.onNext(1);
<add> observer.onNext(2);
<add> observer.onComplete();
<add> observer.onError(new IOException());
<add> }
<add> }
<add> .flatMap(v -> {
<add> throw new TestException();
<add> })
<add> .test()
<add> .assertFailure(TestException.class);
<add>
<add> TestHelper.assertUndeliverable(errors, 0, IOException.class);
<add> });
<add> }
<add>
<add> @Test
<add> public void scalarQueueTerminate() {
<add> PublishSubject<Integer> ps = PublishSubject.create();
<add> TestObserver<Integer> to = new TestObserver<>();
<add>
<add> ps
<add> .flatMap(v -> Observable.just(v))
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> ps.onNext(2);
<add> ps.onNext(3);
<add> }
<add> })
<add> .take(2)
<add> .subscribe(to);
<add>
<add> ps.onNext(1);
<add>
<add> to.assertResult(1, 2);
<add> }
<add>
<add> @Test
<add> public void scalarQueueCompleteMain() throws Exception {
<add> PublishSubject<Integer> ps = PublishSubject.create();
<add> TestObserver<Integer> to = new TestObserver<>();
<add> CountDownLatch cdl = new CountDownLatch(1);
<add> ps
<add> .flatMap(v -> Observable.just(v))
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> ps.onNext(2);
<add> TestHelper.raceOther(() -> ps.onComplete(), cdl);
<add> }
<add> })
<add> .subscribe(to);
<add>
<add> ps.onNext(1);
<add>
<add> cdl.await();
<add> to.assertResult(1, 2);
<add> }
<add>
<add> @Test
<add> public void fusedInnerCrash() {
<add> UnicastSubject<Integer> us = UnicastSubject.create();
<add> PublishSubject<Integer> ps = PublishSubject.create();
<add>
<add> TestObserver<Integer> to = Observable.just(
<add> ps,
<add> us.map(v -> {
<add> if (v == 10) {
<add> throw new TestException();
<add> }
<add> return v;
<add> })
<add> .compose(TestHelper.observableStripBoundary())
<add> )
<add> .flatMap(v -> v, true)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> ps.onNext(2);
<add> us.onNext(10);
<add> }
<add> })
<add> .test();
<add>
<add> ps.onNext(1);
<add> ps.onComplete();
<add>
<add> to.assertFailure(TestException.class, 1, 2);
<add> }
<add>
<add> @Test
<add> public void fusedInnerCrash2() {
<add> UnicastSubject<Integer> us = UnicastSubject.create();
<add> PublishSubject<Integer> ps = PublishSubject.create();
<add>
<add> TestObserver<Integer> to = Observable.just(
<add> us.map(v -> {
<add> if (v == 10) {
<add> throw new TestException();
<add> }
<add> return v;
<add> })
<add> .compose(TestHelper.observableStripBoundary())
<add> , ps
<add> )
<add> .flatMap(v -> v, true)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> ps.onNext(2);
<add> us.onNext(10);
<add> }
<add> })
<add> .test();
<add>
<add> ps.onNext(1);
<add> ps.onComplete();
<add>
<add> to.assertFailure(TestException.class, 1, 2);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFlattenIterableTest.java
<ide> public void remove() {
<ide>
<ide> assertEquals(1, counter.get());
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.flatMapIterable(v -> Collections.singletonList(v)));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFromCompletableTest.java
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.functions.*;
<del>import io.reactivex.rxjava3.internal.fuseable.QueueFuseable;
<add>import io.reactivex.rxjava3.internal.fuseable.*;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> public void syncFusedRejected() throws Throwable {
<ide>
<ide> verify(action).run();
<ide> }
<add>
<add> @Test
<add> public void disposed() {
<add> TestHelper.checkDisposed(Observable.fromCompletable(Completable.never()));
<add> }
<add>
<add> @Test
<add> public void upstream() {
<add> Observable<?> o = Observable.fromCompletable(Completable.never());
<add> assertTrue(o instanceof HasUpstreamCompletableSource);
<add> assertSame(Completable.never(), ((HasUpstreamCompletableSource)o).source());
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFromIterableTest.java
<ide> public void onComplete() {
<ide> }
<ide> });
<ide> }
<add>
<add> @Test
<add> public void disposeAfterHasNext() {
<add> TestObserver<Integer> to = new TestObserver<>();
<add>
<add> Observable.fromIterable(() -> new Iterator<Integer>() {
<add> int count;
<add> @Override
<add> public boolean hasNext() {
<add> if (count++ == 2) {
<add> to.dispose();
<add> return false;
<add> }
<add> return true;
<add> }
<add>
<add> @Override
<add> public Integer next() {
<add> return 1;
<add> }
<add> })
<add> .subscribeWith(to)
<add> .assertValuesOnly(1, 1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableGenerateTest.java
<ide> public void accept(Emitter<Object> e) throws Exception {
<ide> .test()
<ide> .assertResult();
<ide> }
<add>
<add> @Test
<add> public void onNextAfterOnComplete() {
<add> Observable.generate(new Consumer<Emitter<Object>>() {
<add> @Override
<add> public void accept(Emitter<Object> e) throws Exception {
<add> e.onComplete();
<add> e.onNext(1);
<add> }
<add> })
<add> .test()
<add> .assertResult();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableGroupByTest.java
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.core.Observable;
<ide> import io.reactivex.rxjava3.core.Observer;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.observables.GroupedObservable;
<ide> import io.reactivex.rxjava3.observers.*;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<del>import io.reactivex.rxjava3.subjects.PublishSubject;
<add>import io.reactivex.rxjava3.subjects.*;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public class ObservableGroupByTest extends RxJavaTest {
<ide> public void accept(GroupedObservable<Integer, Object> g) throws Throwable {
<ide>
<ide> to2.assertFailure(TestException.class, 1);
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.groupBy(v -> v));
<add> }
<add>
<add> @Test
<add> public void nullKeyDisposeGroup() {
<add> Observable.just(1)
<add> .groupBy(v -> null)
<add> .flatMap(v -> v.take(1))
<add> .test()
<add> .assertResult(1);
<add> }
<add>
<add> @Test
<add> public void groupSubscribeOnNextRace() throws Throwable {
<add> for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
<add> BehaviorSubject<Integer> bs = BehaviorSubject.createDefault(1);
<add> CountDownLatch cdl = new CountDownLatch(1);
<add>
<add> bs.groupBy(v -> 1)
<add> .doOnNext(g -> {
<add> TestHelper.raceOther(() -> {
<add> g.test();
<add> }, cdl);
<add> })
<add> .test();
<add>
<add> cdl.await();
<add> }
<add> }
<add>
<add> @Test
<add> public void abandonedGroupDispose() {
<add> AtomicReference<Observable<Integer>> ref = new AtomicReference<>();
<add>
<add> Observable.just(1)
<add> .groupBy(v -> 1)
<add> .doOnNext(ref::set)
<add> .test();
<add>
<add> ref.get().take(1).test().assertResult(1);
<add> }
<add>
<add> @Test
<add> public void delayErrorCompleteMoreWorkInGroup() {
<add> PublishSubject<Integer> ps = PublishSubject.create();
<add>
<add> TestObserver<Integer> to = ps.groupBy(v -> 1, true)
<add> .flatMap(g -> g.doOnNext(v -> {
<add> if (v == 1) {
<add> ps.onNext(2);
<add> ps.onComplete();
<add> }
<add> })
<add> )
<add> .test()
<add> ;
<add>
<add> ps.onNext(1);
<add>
<add> to.assertResult(1, 2);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableGroupJoinTest.java
<ide> public void leftRightEndState() {
<ide>
<ide> verify(js).innerClose(false, o);
<ide> }
<add>
<add> @Test
<add> public void disposeAfterOnNext() {
<add> PublishSubject<Integer> ps1 = PublishSubject.create();
<add> PublishSubject<Integer> ps2 = PublishSubject.create();
<add>
<add> TestObserver<Integer> to = new TestObserver<>();
<add>
<add> ps1.groupJoin(ps2, v -> Observable.never(), v -> Observable.never(), (a, b) -> a)
<add> .doOnNext(v -> {
<add> to.dispose();
<add> })
<add> .subscribe(to);
<add>
<add> ps2.onNext(1);
<add> ps1.onNext(1);
<add> }
<add>
<add> @Test
<add> public void completeWithMoreWork() {
<add> PublishSubject<Integer> ps1 = PublishSubject.create();
<add> PublishSubject<Integer> ps2 = PublishSubject.create();
<add>
<add> TestObserver<Integer> to = new TestObserver<>();
<add>
<add> ps1.groupJoin(ps2, v -> Observable.never(), v -> Observable.never(), (a, b) -> a)
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> ps2.onNext(2);
<add> ps1.onComplete();
<add> ps2.onComplete();
<add> }
<add> })
<add> .subscribe(to);
<add>
<add> ps2.onNext(1);
<add> ps1.onNext(1);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableIntervalRangeTest.java
<ide> public void cancel() {
<ide> .test()
<ide> .assertResult(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L);
<ide> }
<add>
<add> @Test
<add> public void takeSameAsRange() {
<add> Observable.intervalRange(0, 2, 1, 1, TimeUnit.MILLISECONDS, Schedulers.trampoline())
<add> .take(2)
<add> .test()
<add> .assertResult(0L, 1L);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableJoinTest.java
<ide> public Integer apply(Integer a, Integer b) throws Exception {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void bothTerminateWithWorkRemaining() {
<add> PublishSubject<Integer> ps1 = PublishSubject.create();
<add> PublishSubject<Integer> ps2 = PublishSubject.create();
<add>
<add> TestObserver<Integer> to = ps1.join(
<add> ps2,
<add> v -> Observable.never(),
<add> v -> Observable.never(),
<add> (a, b) -> a + b)
<add> .doOnNext(v -> {
<add> ps1.onComplete();
<add> ps2.onNext(2);
<add> ps2.onComplete();
<add> })
<add> .test();
<add>
<add> ps1.onNext(0);
<add> ps2.onNext(1);
<add>
<add> to.assertComplete();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableRefCountTest.java
<ide> public class ObservableRefCountTest extends RxJavaTest {
<ide>
<ide> @Test
<del> public void refCountAsync() {
<add> public void refCountAsync() throws InterruptedException {
<add> // Flaky
<add> for (int i = 0; i < 10; i++) {
<add> try {
<add> refCountAsyncActual();
<add> return;
<add> } catch (AssertionError ex) {
<add> if (i == 9) {
<add> throw ex;
<add> }
<add> Thread.sleep((int)(200 * (Math.random() * 10 + 1)));
<add> }
<add> }
<add> }
<add>
<add> /**
<add> * Tries to coordinate async counting but it is flaky due to the low 10s of milliseconds.
<add> */
<add> void refCountAsyncActual() {
<ide> final AtomicInteger subscribeCount = new AtomicInteger();
<ide> final AtomicInteger nextCount = new AtomicInteger();
<ide> Observable<Long> r = Observable.interval(0, 25, TimeUnit.MILLISECONDS)
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableReplayTest.java
<ide> public void accept(byte[] v) throws Exception {
<ide> Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
<ide> + " -> " + after.get() / 1024.0 / 1024.0);
<ide> }
<del> }}
<add> }
<add>
<add> @Test(expected = TestException.class)
<add> public void connectDisposeCrash() {
<add> ConnectableObservable<Object> co = Observable.never().replay();
<add>
<add> co.connect();
<add>
<add> co.connect(d -> { throw new TestException(); });
<add> }
<add>
<add> @Test
<add> public void resetWhileNotConnectedIsNoOp() {
<add> ConnectableObservable<Object> co = Observable.never().replay();
<add>
<add> co.reset();
<add> }
<add>
<add> @Test
<add> public void resetWhileActiveIsNoOp() {
<add> ConnectableObservable<Object> co = Observable.never().replay();
<add>
<add> co.connect();
<add>
<add> co.reset();
<add> }
<add>}
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSampleTest.java
<ide> public Observable<Object> apply(Observable<Object> o)
<ide> });
<ide> }
<ide>
<add> @Test
<add> public void doubleOnSubscribeObservable() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.sample(Observable.never()));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableScalarXMapTest.java
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.disposables.EmptyDisposable;
<add>import io.reactivex.rxjava3.internal.fuseable.QueueFuseable;
<ide> import io.reactivex.rxjava3.internal.operators.observable.ObservableScalarXMap.ScalarDisposable;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide> public void run() {
<ide> TestHelper.race(r1, r2);
<ide> }
<ide> }
<add>
<add> @Test
<add> public void scalarDisposbleWrongFusion() {
<add> TestObserver<Integer> to = new TestObserver<>();
<add> final ScalarDisposable<Integer> sd = new ScalarDisposable<>(to, 1);
<add> to.onSubscribe(sd);
<add>
<add> assertEquals(QueueFuseable.NONE, sd.requestFusion(QueueFuseable.ASYNC));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSequenceEqualTest.java
<ide> public void run() {
<ide> to.assertEmpty();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void firstCompletesBeforeSecond() {
<add> Observable.sequenceEqual(Observable.just(1), Observable.empty())
<add> .test()
<add> .assertResult(false);
<add> }
<add>
<add> @Test
<add> public void secondCompletesBeforeFirst() {
<add> Observable.sequenceEqual(Observable.empty(), Observable.just(1))
<add> .test()
<add> .assertResult(false);
<add> }
<add>
<add> @Test
<add> public void bothEmpty() {
<add> Observable.sequenceEqual(Observable.empty(), Observable.empty())
<add> .test()
<add> .assertResult(true);
<add> }
<add>
<add> @Test
<add> public void bothJust() {
<add> Observable.sequenceEqual(Observable.just(1), Observable.just(1))
<add> .test()
<add> .assertResult(true);
<add> }
<add>
<add> @Test
<add> public void bothCompleteWhileComparing() {
<add> PublishSubject<Integer> ps1 = PublishSubject.create();
<add> PublishSubject<Integer> ps2 = PublishSubject.create();
<add>
<add> TestObserver<Boolean> to = Observable.sequenceEqual(ps1, ps2, (a, b) -> {
<add> ps1.onNext(1);
<add> ps1.onComplete();
<add>
<add> ps2.onNext(1);
<add> ps2.onComplete();
<add> return a.equals(b);
<add> })
<add> .test()
<add> ;
<add>
<add> ps1.onNext(0);
<add> ps2.onNext(0);
<add>
<add> to.assertResult(true);
<add> }
<add>
<add> @Test
<add> public void bothCompleteWhileComparingAsObservable() {
<add> PublishSubject<Integer> ps1 = PublishSubject.create();
<add> PublishSubject<Integer> ps2 = PublishSubject.create();
<add>
<add> TestObserver<Boolean> to = Observable.sequenceEqual(ps1, ps2, (a, b) -> {
<add> ps1.onNext(1);
<add> ps1.onComplete();
<add>
<add> ps2.onNext(1);
<add> ps2.onComplete();
<add> return a.equals(b);
<add> })
<add> .toObservable()
<add> .test()
<add> ;
<add>
<add> ps1.onNext(0);
<add> ps2.onNext(0);
<add>
<add> to.assertResult(true);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSkipLastTimedTest.java
<ide> public ObservableSource<Object> apply(Observable<Object> o) throws Exception {
<ide> }
<ide>
<ide> @Test
<del> public void onNextDisposeRace() {
<add> public void onCompleteDisposeRace() {
<ide> TestScheduler scheduler = new TestScheduler();
<ide> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<ide> final PublishSubject<Integer> ps = PublishSubject.create();
<ide> public void run() {
<ide> }
<ide> }
<ide>
<add> @Test
<add> public void onCompleteDisposeDelayErrorRace() {
<add> TestScheduler scheduler = new TestScheduler();
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> final PublishSubject<Integer> ps = PublishSubject.create();
<add>
<add> final TestObserver<Integer> to = ps.skipLast(1, TimeUnit.DAYS, scheduler, true).test();
<add>
<add> Runnable r1 = new Runnable() {
<add> @Override
<add> public void run() {
<add> ps.onComplete();
<add> }
<add> };
<add>
<add> Runnable r2 = new Runnable() {
<add> @Override
<add> public void run() {
<add> to.dispose();
<add> }
<add> };
<add>
<add> TestHelper.race(r1, r2);
<add> }
<add> }
<add>
<ide> @Test
<ide> public void errorDelayed() {
<ide> Observable.error(new TestException())
<ide> public void take() {
<ide> .awaitDone(5, TimeUnit.SECONDS)
<ide> .assertResult(1);
<ide> }
<add>
<add> @Test
<add> public void onNextDisposeRace() {
<add> TestScheduler scheduler = new TestScheduler();
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> final PublishSubject<Integer> ps = PublishSubject.create();
<add>
<add> final TestObserver<Integer> to = ps.skipLast(1, TimeUnit.DAYS, scheduler).test();
<add>
<add> Runnable r1 = new Runnable() {
<add> @Override
<add> public void run() {
<add> ps.onNext(1);
<add> }
<add> };
<add>
<add> Runnable r2 = new Runnable() {
<add> @Override
<add> public void run() {
<add> to.dispose();
<add> }
<add> };
<add>
<add> TestHelper.race(r1, r2);
<add> }
<add> }
<add>
<add> @Test
<add> public void onNextOnCompleteDisposeDelayErrorRace() {
<add> TestScheduler scheduler = new TestScheduler();
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> final PublishSubject<Integer> ps = PublishSubject.create();
<add>
<add> final TestObserver<Integer> to = ps.skipLast(1, TimeUnit.DAYS, scheduler, true).test();
<add>
<add> Runnable r1 = new Runnable() {
<add> @Override
<add> public void run() {
<add> ps.onNext(1);
<add> ps.onComplete();
<add> }
<add> };
<add>
<add> Runnable r2 = new Runnable() {
<add> @Override
<add> public void run() {
<add> to.dispose();
<add> }
<add> };
<add>
<add> TestHelper.race(r1, r2);
<add> }
<add> }
<add>
<add> @Test
<add> public void skipLastTimedDelayError() {
<add> TestScheduler scheduler = new TestScheduler();
<add>
<add> PublishSubject<Integer> source = PublishSubject.create();
<add>
<add> // FIXME the timeunit now matters due to rounding
<add> Observable<Integer> result = source.skipLast(1000, TimeUnit.MILLISECONDS, scheduler, true);
<add>
<add> Observer<Object> o = TestHelper.mockObserver();
<add>
<add> result.subscribe(o);
<add>
<add> source.onNext(1);
<add> source.onNext(2);
<add> source.onNext(3);
<add>
<add> scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
<add>
<add> source.onNext(4);
<add> source.onNext(5);
<add> source.onNext(6);
<add>
<add> scheduler.advanceTimeBy(950, TimeUnit.MILLISECONDS);
<add> source.onComplete();
<add>
<add> InOrder inOrder = inOrder(o);
<add> inOrder.verify(o).onNext(1);
<add> inOrder.verify(o).onNext(2);
<add> inOrder.verify(o).onNext(3);
<add> inOrder.verify(o, never()).onNext(4);
<add> inOrder.verify(o, never()).onNext(5);
<add> inOrder.verify(o, never()).onNext(6);
<add> inOrder.verify(o).onComplete();
<add> inOrder.verifyNoMoreInteractions();
<add>
<add> verify(o, never()).onError(any(Throwable.class));
<add> }
<add>
<add> @Test
<add> public void skipLastTimedErrorBeforeTimeDelayError() {
<add> TestScheduler scheduler = new TestScheduler();
<add>
<add> PublishSubject<Integer> source = PublishSubject.create();
<add>
<add> Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler, true);
<add>
<add> Observer<Object> o = TestHelper.mockObserver();
<add>
<add> result.subscribe(o);
<add>
<add> source.onNext(1);
<add> source.onNext(2);
<add> source.onNext(3);
<add> source.onError(new TestException());
<add>
<add> scheduler.advanceTimeBy(1050, TimeUnit.MILLISECONDS);
<add>
<add> verify(o).onError(any(TestException.class));
<add>
<add> verify(o, never()).onComplete();
<add> verify(o, never()).onNext(any());
<add> }
<add>
<add> @Test
<add> public void skipLastTimedCompleteBeforeTimeDelayError() {
<add> TestScheduler scheduler = new TestScheduler();
<add>
<add> PublishSubject<Integer> source = PublishSubject.create();
<add>
<add> Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler, true);
<add>
<add> Observer<Object> o = TestHelper.mockObserver();
<add>
<add> result.subscribe(o);
<add>
<add> source.onNext(1);
<add> source.onNext(2);
<add> source.onNext(3);
<add>
<add> scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
<add>
<add> source.onComplete();
<add>
<add> InOrder inOrder = inOrder(o);
<add> inOrder.verify(o).onComplete();
<add> inOrder.verifyNoMoreInteractions();
<add>
<add> verify(o, never()).onNext(any());
<add> verify(o, never()).onError(any(Throwable.class));
<add> }
<add>
<add> @Test
<add> public void skipLastTimedWhenAllElementsAreValidDelayError() {
<add> TestScheduler scheduler = new TestScheduler();
<add>
<add> PublishSubject<Integer> source = PublishSubject.create();
<add>
<add> Observable<Integer> result = source.skipLast(1, TimeUnit.MILLISECONDS, scheduler, true);
<add>
<add> Observer<Object> o = TestHelper.mockObserver();
<add>
<add> result.subscribe(o);
<add>
<add> source.onNext(1);
<add> source.onNext(2);
<add> source.onNext(3);
<add>
<add> scheduler.advanceTimeBy(500, TimeUnit.MILLISECONDS);
<add>
<add> source.onComplete();
<add>
<add> InOrder inOrder = inOrder(o);
<add> inOrder.verify(o).onNext(1);
<add> inOrder.verify(o).onNext(2);
<add> inOrder.verify(o).onNext(3);
<add> inOrder.verify(o).onComplete();
<add> inOrder.verifyNoMoreInteractions();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSwitchTest.java
<ide> import org.junit.*;
<ide> import org.mockito.InOrder;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.core.Observable;
<ide> import io.reactivex.rxjava3.core.Observer;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> public Observable<Integer> apply(Integer v)
<ide> .test()
<ide> .assertResult(10, 20);
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeObservable(f -> f.switchMap(v -> Observable.never()));
<add> }
<add>
<add> @Test
<add> public void mainCompleteCancelRace() {
<add> for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
<add> AtomicReference<Observer<? super Integer>> ref = new AtomicReference<>();
<add> Observable<Integer> o = new Observable<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull Observer<? super @NonNull Integer> observer) {
<add> ref.set(observer);
<add> }
<add> };
<add>
<add> TestObserver<Object> to = o.switchMap(v -> Observable.never())
<add> .test();
<add>
<add> ref.get().onSubscribe(Disposable.empty());
<add>
<add> TestHelper.race(
<add> () -> ref.get().onComplete(),
<add> () -> to.dispose()
<add> );
<add> }
<add> }
<add>
<add> @Test
<add> public void mainCompleteInnerErrorRace() {
<add> TestException ex = new TestException();
<add>
<add> for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
<add> AtomicReference<Observer<? super Integer>> ref1 = new AtomicReference<>();
<add> Observable<Integer> o1 = new Observable<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull Observer<? super @NonNull Integer> observer) {
<add> ref1.set(observer);
<add> }
<add> };
<add> AtomicReference<Observer<? super Integer>> ref2 = new AtomicReference<>();
<add> Observable<Integer> o2 = new Observable<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull Observer<? super @NonNull Integer> observer) {
<add> ref2.set(observer);
<add> }
<add> };
<add>
<add> o1.switchMap(v -> o2)
<add> .test();
<add>
<add> ref1.get().onSubscribe(Disposable.empty());
<add> ref1.get().onNext(1);
<add> ref2.get().onSubscribe(Disposable.empty());
<add>
<add> TestHelper.race(
<add> () -> ref1.get().onComplete(),
<add> () -> ref2.get().onError(ex)
<add> );
<add> }
<add> }
<add>
<add> @Test
<add> public void innerNoSubscriptionYet() {
<add> AtomicReference<Observer<? super Integer>> ref1 = new AtomicReference<>();
<add> Observable<Integer> o1 = new Observable<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull Observer<? super @NonNull Integer> observer) {
<add> ref1.set(observer);
<add> }
<add> };
<add> AtomicReference<Observer<? super Integer>> ref2 = new AtomicReference<>();
<add> Observable<Integer> o2 = new Observable<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull Observer<? super @NonNull Integer> observer) {
<add> ref2.set(observer);
<add> }
<add> };
<add>
<add> o1.switchMap(v -> o2)
<add> .test();
<add>
<add> ref1.get().onSubscribe(Disposable.empty());
<add> ref1.get().onNext(1);
<add> ref1.get().onComplete();
<add> }
<add>
<add> @Test
<add> public void switchDuringOnNext() {
<add> PublishSubject<Integer> ps = PublishSubject.create();
<add>
<add> TestObserver<Integer> to = ps.switchMap(v -> Observable.range(v, 5))
<add> .doOnNext(v -> {
<add> if (v == 1) {
<add> ps.onNext(2);
<add> }
<add> })
<add> .test();
<add>
<add> ps.onNext(1);
<add>
<add> to
<add> .assertValuesOnly(1, 2, 3, 4, 5, 6);
<add> }
<add>
<add> @Test
<add> public void mainCompleteWhileInnerActive() {
<add> PublishSubject<Integer> ps1 = PublishSubject.create();
<add> PublishSubject<Integer> ps2 = PublishSubject.create();
<add>
<add> TestObserver<Integer> to = ps1.switchMapDelayError(v -> ps2)
<add> .test();
<add>
<add> ps1.onNext(1);
<add> ps1.onComplete();
<add>
<add> ps2.onComplete();
<add>
<add> to.assertResult();
<add> }
<add>
<add> @Test
<add> public void innerIgnoresCancelAndErrors() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> PublishSubject<Integer> ps = PublishSubject.create();
<add>
<add> TestObserver<Object> to = ps
<add> .switchMap(v -> {
<add> if (v == 1) {
<add> return Observable.unsafeCreate(s -> {
<add> s.onSubscribe(Disposable.empty());
<add> ps.onNext(2);
<add> s.onError(new TestException());
<add> });
<add> }
<add> return Observable.never();
<add> })
<add> .test();
<add>
<add> ps.onNext(1);
<add>
<add> to.assertEmpty();
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> });
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTakeLastTimedTest.java
<ide> public void lastWindowIsFixedInTime() {
<ide>
<ide> to.assertResult(1, 2, 3, 4);
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.takeLast(1, TimeUnit.SECONDS));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableThrottleFirstTest.java
<ide> import static org.mockito.ArgumentMatchers.any;
<ide> import static org.mockito.Mockito.*;
<ide>
<del>import java.util.List;
<ide> import java.util.concurrent.TimeUnit;
<ide>
<del>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import org.junit.*;
<ide> import org.mockito.InOrder;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<del>import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.schedulers.TestScheduler;
<ide> import io.reactivex.rxjava3.subjects.PublishSubject;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide> public void dispose() {
<ide> }
<ide>
<ide> @Test
<del> public void badSource() {
<del> List<Throwable> errors = TestHelper.trackPluginErrors();
<del> try {
<del> new Observable<Integer>() {
<del> @Override
<del> protected void subscribeActual(Observer<? super Integer> observer) {
<del> observer.onSubscribe(Disposable.empty());
<del> observer.onNext(1);
<del> observer.onNext(2);
<del> observer.onComplete();
<del> observer.onNext(3);
<del> observer.onError(new TestException());
<del> observer.onComplete();
<del> }
<del> }
<del> .throttleFirst(1, TimeUnit.DAYS)
<del> .test()
<del> .assertResult(1);
<del>
<del> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<del> } finally {
<del> RxJavaPlugins.reset();
<del> }
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.throttleFirst(1, TimeUnit.SECONDS));
<ide> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableUnsubscribeOnTest.java
<ide> import io.reactivex.rxjava3.disposables.*;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.Action;
<add>import io.reactivex.rxjava3.internal.schedulers.ImmediateThinScheduler;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide> protected void subscribeActual(Observer<? super Integer> observer) {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.unsubscribeOn(ImmediateThinScheduler.INSTANCE));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableWindowWithStartEndObservableTest.java
<ide>
<ide> import static org.junit.Assert.*;
<ide>
<add>import java.io.IOException;
<ide> import java.util.*;
<ide> import java.util.concurrent.TimeUnit;
<ide> import java.util.concurrent.atomic.*;
<ide>
<del>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import org.junit.*;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.core.Observable;
<ide> import io.reactivex.rxjava3.core.Observer;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> public void mainError() {
<ide> .test()
<ide> .assertFailure(TestException.class);
<ide> }
<del>}
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.window(Observable.never(), v -> Observable.never()));
<add> }
<add>
<add> @Test
<add> public void openError() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> TestException ex1 = new TestException();
<add> TestException ex2 = new TestException();
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> AtomicReference<Observer<? super Integer>> ref1 = new AtomicReference<>();
<add> AtomicReference<Observer<? super Integer>> ref2 = new AtomicReference<>();
<add>
<add> Observable<Integer> o1 = Observable.<Integer>unsafeCreate(ref1::set);
<add> Observable<Integer> o2 = Observable.<Integer>unsafeCreate(ref2::set);
<add>
<add> TestObserver<Observable<Integer>> to = BehaviorSubject.createDefault(1)
<add> .window(o1, v -> o2)
<add> .doOnNext(w -> w.test())
<add> .test();
<add>
<add> ref1.get().onSubscribe(Disposable.empty());
<add> ref1.get().onNext(1);
<add> ref2.get().onSubscribe(Disposable.empty());
<add>
<add> TestHelper.race(
<add> () -> ref1.get().onError(ex1),
<add> () -> ref2.get().onError(ex2)
<add> );
<add>
<add> to.assertError(RuntimeException.class);
<add>
<add> if (!errors.isEmpty()) {
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> }
<add>
<add> errors.clear();
<add> }
<add> });
<add> }
<add>
<add> @Test
<add> public void closeError() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> AtomicReference<Observer<? super Integer>> ref1 = new AtomicReference<>();
<add> AtomicReference<Observer<? super Integer>> ref2 = new AtomicReference<>();
<add>
<add> Observable<Integer> o1 = Observable.<Integer>unsafeCreate(ref1::set);
<add> Observable<Integer> o2 = Observable.<Integer>unsafeCreate(ref2::set);
<add>
<add> TestObserver<Integer> to = BehaviorSubject.createDefault(1)
<add> .window(o1, v -> o2)
<add> .flatMap(v -> v)
<add> .test();
<add>
<add> ref1.get().onSubscribe(Disposable.empty());
<add> ref1.get().onNext(1);
<add> ref2.get().onSubscribe(Disposable.empty());
<add>
<add> ref2.get().onError(new TestException());
<add> ref2.get().onError(new TestException());
<add>
<add> to.assertFailure(TestException.class);
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> });
<add> }
<add>
<add> @Test
<add> public void upstreamFailsBeforeFirstWindow() {
<add> Observable.error(new TestException())
<add> .window(Observable.never(), v -> Observable.never())
<add> .test()
<add> .assertFailure(TestException.class);
<add> }
<add>
<add> @Test
<add> public void windowOpenMainCompletes() {
<add> AtomicReference<Observer<? super Integer>> ref1 = new AtomicReference<>();
<add>
<add> PublishSubject<Object> ps = PublishSubject.create();
<add> Observable<Integer> o1 = Observable.<Integer>unsafeCreate(ref1::set);
<add>
<add> AtomicInteger counter = new AtomicInteger();
<add>
<add> TestObserver<Observable<Object>> to = ps
<add> .window(o1, v -> Observable.never())
<add> .doOnNext(w -> {
<add> if (counter.getAndIncrement() == 0) {
<add> ref1.get().onNext(2);
<add> ps.onNext(1);
<add> ps.onComplete();
<add> }
<add> w.test();
<add> })
<add> .test();
<add>
<add> ref1.get().onSubscribe(Disposable.empty());
<add> ref1.get().onNext(1);
<add>
<add> to.assertComplete();
<add> }
<add>
<add> @Test
<add> public void windowOpenMainError() {
<add> AtomicReference<Observer<? super Integer>> ref1 = new AtomicReference<>();
<add>
<add> PublishSubject<Object> ps = PublishSubject.create();
<add> Observable<Integer> o1 = Observable.<Integer>unsafeCreate(ref1::set);
<add>
<add> AtomicInteger counter = new AtomicInteger();
<add>
<add> TestObserver<Observable<Object>> to = ps
<add> .window(o1, v -> Observable.never())
<add> .doOnNext(w -> {
<add> if (counter.getAndIncrement() == 0) {
<add> ref1.get().onNext(2);
<add> ps.onNext(1);
<add> ps.onError(new TestException());
<add> }
<add> w.test();
<add> })
<add> .test();
<add>
<add> ref1.get().onSubscribe(Disposable.empty());
<add> ref1.get().onNext(1);
<add>
<add> to.assertError(TestException.class);
<add> }
<add>
<add> @Test
<add> public void windowOpenIgnoresDispose() {
<add> AtomicReference<Observer<? super Integer>> ref1 = new AtomicReference<>();
<add>
<add> PublishSubject<Object> ps = PublishSubject.create();
<add> Observable<Integer> o1 = Observable.<Integer>unsafeCreate(ref1::set);
<add>
<add> TestObserver<Observable<Object>> to = ps
<add> .window(o1, v -> Observable.never())
<add> .take(1)
<add> .doOnNext(w -> {
<add> w.test();
<add> })
<add> .test();
<add>
<add> ref1.get().onSubscribe(Disposable.empty());
<add> ref1.get().onNext(1);
<add> ref1.get().onNext(2);
<add>
<add> to.assertValueCount(1);
<add> }
<add>
<add> @Test
<add> public void mainIgnoresCancelBeforeOnError() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> Observable.unsafeCreate(s -> {
<add> s.onSubscribe(Disposable.empty());
<add> s.onNext(1);
<add> s.onError(new IOException());
<add> })
<add> .window(BehaviorSubject.createDefault(1), v -> Observable.error(new TestException()))
<add> .doOnNext(w -> w.test())
<add> .test()
<add> .assertError(TestException.class);
<add>
<add> TestHelper.assertUndeliverable(errors, 0, IOException.class);
<add> });
<add> }
<add>}
<ide>\ No newline at end of file
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableWindowWithTimeTest.java
<ide> public void accept(Observable<Integer> v) throws Throwable {
<ide>
<ide> inner.get().test().assertResult();
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeObservable(o -> o.window(1, TimeUnit.SECONDS));
<add> }
<add>
<add> @Test
<add> public void timedBoundarySignalAndDisposeRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> TestScheduler scheduler = new TestScheduler();
<add>
<add> PublishSubject<Integer> ps = PublishSubject.create();
<add>
<add> TestObserver<Observable<Integer>> to = ps.window(1, TimeUnit.MINUTES, scheduler, 1)
<add> .test();
<add>
<add> TestHelper.race(
<add> () -> ps.onNext(1),
<add> () -> to.dispose()
<add> );
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/single/SingleDelayTest.java
<ide> import java.util.concurrent.*;
<ide> import java.util.concurrent.atomic.AtomicReference;
<ide>
<del>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import org.junit.Test;
<ide> import org.reactivestreams.Subscriber;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.schedulers.*;
<del>import io.reactivex.rxjava3.subjects.PublishSubject;
<add>import io.reactivex.rxjava3.subjects.*;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public class SingleDelayTest extends RxJavaTest {
<ide> public Single<Object> apply(Single<Object> s) throws Exception {
<ide> });
<ide>
<ide> }
<add>
<add> @Test
<add> public void withPublisherDoubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowableToSingle(
<add> f -> SingleSubject.create().delaySubscription(f));
<add> }
<add>
<add> @Test
<add> public void withObservableDoubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeObservableToSingle(
<add> o -> SingleSubject.create().delaySubscription(o));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/single/SingleEqualsTest.java
<ide>
<ide> public class SingleEqualsTest extends RxJavaTest {
<ide>
<add> @Test
<add> public void bothSucceedEqual() {
<add> Single.sequenceEqual(Single.just(1), Single.just(1))
<add> .test()
<add> .assertResult(true);
<add> }
<add>
<add> @Test
<add> public void bothSucceedNotEqual() {
<add> Single.sequenceEqual(Single.just(1), Single.just(2))
<add> .test()
<add> .assertResult(false);
<add> }
<add>
<add> @Test
<add> public void firstSucceedOtherError() {
<add> Single.sequenceEqual(Single.just(1), Single.error(new TestException()))
<add> .test()
<add> .assertFailure(TestException.class);
<add> }
<add>
<add> @Test
<add> public void firstErrorOtherSucceed() {
<add> Single.sequenceEqual(Single.error(new TestException()), Single.just(1))
<add> .test()
<add> .assertFailure(TestException.class);
<add> }
<add>
<ide> @Test
<ide> public void bothError() {
<ide> List<Throwable> errors = TestHelper.trackPluginErrors();
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/single/SingleFlatMapIterableFlowableTest.java
<ide> import org.junit.Test;
<ide> import org.reactivestreams.Subscription;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.Function;
<ide> import io.reactivex.rxjava3.internal.fuseable.*;
<ide> import io.reactivex.rxjava3.internal.util.CrashingIterable;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<del>import io.reactivex.rxjava3.subjects.PublishSubject;
<add>import io.reactivex.rxjava3.subjects.*;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public void run() {
<ide> TestHelper.race(r1, r2);
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeSingleToFlowable(s -> s.flattenAsFlowable(v -> Collections.emptyList()));
<add> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(SingleSubject.create().flattenAsFlowable(v -> Collections.emptyList()));
<add> }
<add>
<add> @Test
<add> public void slowPatchCancelAfterOnNext() {
<add> TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> super.onNext(t);
<add> cancel();
<add> onComplete();
<add> }
<add> };
<add>
<add> Single.just(1)
<add> .flattenAsFlowable(v -> Arrays.asList(1, 2))
<add> .subscribe(ts);
<add>
<add> ts.assertResult(1);
<add> }
<add>
<add> @Test
<add> public void onSuccessRequestRace() {
<add> List<Object> list = Arrays.asList(1);
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add>
<add> SingleSubject<Integer> ss = SingleSubject.create();
<add>
<add> TestSubscriber<Object> ts = ss.flattenAsFlowable(v -> list)
<add> .test(0L);
<add>
<add> TestHelper.race(
<add> () -> ss.onSuccess(1),
<add> () -> ts.request(1)
<add> );
<add>
<add> ts.assertResult(1);
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/single/SingleInternalHelperTest.java
<ide> public void utilityClass() {
<ide>
<ide> @Test
<ide> public void noSuchElementCallableEnum() {
<del> assertEquals(1, SingleInternalHelper.NoSuchElementCallable.values().length);
<del> assertNotNull(SingleInternalHelper.NoSuchElementCallable.valueOf("INSTANCE"));
<add> assertEquals(1, SingleInternalHelper.NoSuchElementSupplier.values().length);
<add> assertNotNull(SingleInternalHelper.NoSuchElementSupplier.valueOf("INSTANCE"));
<ide> }
<ide>
<ide> @Test
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/single/SingleTimeoutTest.java
<ide>
<ide> import org.junit.Test;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.Action;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> public void run() {
<ide> public void mainTimedOut() {
<ide> Single
<ide> .never()
<del> .timeout(1, TimeUnit.NANOSECONDS)
<add> .timeout(1, TimeUnit.MILLISECONDS)
<ide> .to(TestHelper.<Object>testConsumer())
<ide> .awaitDone(5, TimeUnit.SECONDS)
<del> .assertFailureAndMessage(TimeoutException.class, timeoutMessage(1, TimeUnit.NANOSECONDS));
<add> .assertFailureAndMessage(TimeoutException.class, timeoutMessage(1, TimeUnit.MILLISECONDS));
<add> }
<add>
<add> @Test
<add> public void mainTimeoutFallbackSuccess() {
<add> Single.never()
<add> .timeout(1, TimeUnit.MILLISECONDS, Single.just(1))
<add> .test()
<add> .awaitDone(5, TimeUnit.SECONDS)
<add> .assertResult(1);
<add> }
<add>
<add> @Test
<add> public void timeoutBeforeOnSubscribeFromMain() {
<add> Disposable d = Disposable.empty();
<add>
<add> new Single<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull SingleObserver<? super @NonNull Integer> observer) {
<add> try {
<add> Thread.sleep(100);
<add> } catch (InterruptedException e) {
<add> e.printStackTrace();
<add> }
<add> observer.onSubscribe(d);
<add> }
<add> }
<add> .timeout(1, TimeUnit.MILLISECONDS, Single.just(1))
<add> .test()
<add> .awaitDone(5, TimeUnit.SECONDS)
<add> .assertResult(1);
<add>
<add> assertTrue(d.isDisposed());
<ide> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/operators/single/SingleZipArrayTest.java
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.PublishProcessor;
<add>import io.reactivex.rxjava3.subjects.SingleSubject;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public class SingleZipArrayTest extends RxJavaTest {
<ide> public void singleSourceZipperReturnsNull() {
<ide> .to(TestHelper.<Object>testConsumer())
<ide> .assertFailureAndMessage(NullPointerException.class, "The zipper returned a null value");
<ide> }
<add>
<add> @Test
<add> public void singleSourceZipperReturnsNull2() {
<add> Single.zipArray(Functions.justFunction(null), Single.just(1), Single.just(2))
<add> .to(TestHelper.<Object>testConsumer())
<add> .assertFailureAndMessage(NullPointerException.class, "The zipper returned a null value");
<add> }
<add>
<add> @Test
<add> public void dispose2() {
<add> TestHelper.checkDisposed(Single.zipArray(Functions.justFunction(1), SingleSubject.create(), SingleSubject.create()));
<add> }
<add>
<add> @Test
<add> public void bothSucceed() {
<add> Single.zipArray(a -> Arrays.asList(a), Single.just(1), Single.just(2))
<add> .test()
<add> .assertResult(Arrays.asList(1, 2));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/schedulers/IoSchedulerInternalTest.java
<add>/**
<add> * Copyright (c) 2016-present, RxJava Contributors.
<add> *
<add> * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
<add> * compliance with the License. You may obtain a copy of the License at
<add> *
<add> * http://www.apache.org/licenses/LICENSE-2.0
<add> *
<add> * Unless required by applicable law or agreed to in writing, software distributed under the License is
<add> * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
<add> * the License for the specific language governing permissions and limitations under the License.
<add> */
<add>
<add>package io.reactivex.rxjava3.internal.schedulers;
<add>
<add>import static org.junit.Assert.*;
<add>import java.util.concurrent.ConcurrentLinkedQueue;
<add>
<add>import org.junit.Test;
<add>
<add>import io.reactivex.rxjava3.core.RxJavaTest;
<add>import io.reactivex.rxjava3.disposables.CompositeDisposable;
<add>import io.reactivex.rxjava3.internal.schedulers.IoScheduler.*;
<add>import io.reactivex.rxjava3.testsupport.TestHelper;
<add>
<add>public class IoSchedulerInternalTest extends RxJavaTest {
<add>
<add> @Test
<add> public void expiredQueueEmpty() {
<add> ConcurrentLinkedQueue<ThreadWorker> expire = new ConcurrentLinkedQueue<>();
<add> CompositeDisposable cd = new CompositeDisposable();
<add>
<add> CachedWorkerPool.evictExpiredWorkers(expire, cd);
<add> }
<add>
<add> @Test
<add> public void expiredWorkerRemoved() {
<add> ConcurrentLinkedQueue<ThreadWorker> expire = new ConcurrentLinkedQueue<>();
<add> CompositeDisposable cd = new CompositeDisposable();
<add>
<add> ThreadWorker tw = new ThreadWorker(new RxThreadFactory("IoExpiryTest"));
<add>
<add> try {
<add> expire.add(tw);
<add> cd.add(tw);
<add>
<add> CachedWorkerPool.evictExpiredWorkers(expire, cd);
<add>
<add> assertTrue(tw.isDisposed());
<add> assertTrue(expire.isEmpty());
<add> } finally {
<add> tw.dispose();
<add> }
<add> }
<add>
<add> @Test
<add> public void noExpiredWorker() {
<add> ConcurrentLinkedQueue<ThreadWorker> expire = new ConcurrentLinkedQueue<>();
<add> CompositeDisposable cd = new CompositeDisposable();
<add>
<add> ThreadWorker tw = new ThreadWorker(new RxThreadFactory("IoExpiryTest"));
<add> tw.setExpirationTime(System.nanoTime() + 10_000_000_000L);
<add>
<add> try {
<add> expire.add(tw);
<add> cd.add(tw);
<add>
<add> CachedWorkerPool.evictExpiredWorkers(expire, cd);
<add>
<add> assertFalse(tw.isDisposed());
<add> assertFalse(expire.isEmpty());
<add> } finally {
<add> tw.dispose();
<add> }
<add> }
<add>
<add> @Test
<add> public void expireReuseRace() {
<add> ConcurrentLinkedQueue<ThreadWorker> expire = new ConcurrentLinkedQueue<>();
<add> CompositeDisposable cd = new CompositeDisposable();
<add>
<add> ThreadWorker tw = new ThreadWorker(new RxThreadFactory("IoExpiryTest"));
<add> tw.dispose();
<add>
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> expire.add(tw);
<add> cd.add(tw);
<add>
<add> TestHelper.race(
<add> () -> CachedWorkerPool.evictExpiredWorkers(expire, cd),
<add> () -> expire.remove(tw)
<add> );
<add> }
<add> }
<add>}
<ide><path>src/test/java/io/reactivex/rxjava3/internal/schedulers/SingleSchedulerTest.java
<ide> package io.reactivex.rxjava3.internal.schedulers;
<ide>
<ide> import static org.junit.Assert.*;
<add>import static org.mockito.Mockito.*;
<ide>
<del>import java.util.concurrent.TimeUnit;
<add>import java.util.concurrent.*;
<ide>
<ide> import org.junit.Test;
<ide>
<ide> import io.reactivex.rxjava3.core.Scheduler;
<ide> import io.reactivex.rxjava3.core.Scheduler.Worker;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.schedulers.SingleScheduler.ScheduledWorker;
<add>import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.schedulers.*;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public void runnableDisposedAsyncTimed() throws Exception {
<ide> return Schedulers.single();
<ide> }
<ide>
<add> @Test
<add> public void zeroPeriodRejectedExecution() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> Scheduler s = RxJavaPlugins.createSingleScheduler(new RxThreadFactory("Test"));
<add> s.shutdown();
<add> Runnable run = mock(Runnable.class);
<add>
<add> s.schedulePeriodicallyDirect(run, 1, 0, TimeUnit.MILLISECONDS);
<add>
<add> Thread.sleep(100);
<add>
<add> verify(run, never()).run();
<add>
<add> TestHelper.assertUndeliverable(errors, 0, RejectedExecutionException.class);
<add> });
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/schedulers/TrampolineSchedulerInternalTest.java
<ide> import static org.mockito.Mockito.*;
<ide>
<ide> import java.util.concurrent.TimeUnit;
<add>import java.util.concurrent.atomic.AtomicInteger;
<ide>
<ide> import org.junit.Test;
<ide>
<del>import io.reactivex.rxjava3.core.RxJavaTest;
<add>import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.core.Scheduler.Worker;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.internal.disposables.EmptyDisposable;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.schedulers.TrampolineScheduler.*;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<add>import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public class TrampolineSchedulerInternalTest extends RxJavaTest {
<ide>
<ide> public void run() {
<ide>
<ide> verify(r, never()).run();
<ide> }
<add>
<add> @Test
<add> public void submitAndDisposeNextTask() {
<add> Scheduler.Worker w = Schedulers.trampoline().createWorker();
<add>
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> Runnable run = mock(Runnable.class);
<add>
<add> AtomicInteger sync = new AtomicInteger(2);
<add>
<add> w.schedule(() -> {
<add> Disposable d = w.schedule(run);
<add>
<add> Schedulers.single().scheduleDirect(() -> {
<add> if (sync.decrementAndGet() != 0) {
<add> while (sync.get() != 0) { }
<add> }
<add> d.dispose();
<add> });
<add> if (sync.decrementAndGet() != 0) {
<add> while (sync.get() != 0) { }
<add> }
<add> });
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/subscribers/BasicFuseableConditionalSubscriberTest.java
<ide> package io.reactivex.rxjava3.internal.subscribers;
<ide>
<ide> import static org.junit.Assert.*;
<add>import static org.mockito.ArgumentMatchers.any;
<add>import static org.mockito.Mockito.*;
<ide>
<ide> import org.junit.Test;
<ide> import org.reactivestreams.Subscription;
<ide>
<del>import io.reactivex.rxjava3.annotations.Nullable;
<del>import io.reactivex.rxjava3.core.RxJavaTest;
<del>import io.reactivex.rxjava3.internal.fuseable.ConditionalSubscriber;
<del>import io.reactivex.rxjava3.internal.subscriptions.ScalarSubscription;
<del>import io.reactivex.rxjava3.testsupport.TestHelper;
<add>import io.reactivex.rxjava3.annotations.*;
<add>import io.reactivex.rxjava3.core.*;
<add>import io.reactivex.rxjava3.internal.fuseable.*;
<add>import io.reactivex.rxjava3.internal.subscriptions.*;
<add>import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public class BasicFuseableConditionalSubscriberTest extends RxJavaTest {
<ide>
<ide> public Integer poll() throws Exception {
<ide> fcs.clear();
<ide> assertTrue(fcs.isEmpty());
<ide> }
<add>
<add> @Test
<add> public void implementationStopsOnSubscribe() {
<add> @SuppressWarnings("unchecked")
<add> ConditionalSubscriber<Integer> ts = mock(ConditionalSubscriber.class);
<add>
<add> BasicFuseableConditionalSubscriber<Integer, Integer> bfs = new BasicFuseableConditionalSubscriber<Integer, Integer>(ts) {
<add>
<add> @Override
<add> protected boolean beforeDownstream() {
<add> return false;
<add> }
<add>
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> ts.onNext(t);
<add> }
<add>
<add> @Override
<add> public int requestFusion(int mode) {
<add> // TODO Auto-generated method stub
<add> return 0;
<add> }
<add>
<add> @Override
<add> public boolean tryOnNext(@NonNull Integer t) {
<add> // TODO Auto-generated method stub
<add> return false;
<add> }
<add>
<add> @Override
<add> public @Nullable Integer poll() throws Throwable {
<add> return null;
<add> }
<add> };
<add>
<add> bfs.onSubscribe(new BooleanSubscription());
<add>
<add> verify(ts, never()).onSubscribe(any());
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> f
<add> .map(v -> v)
<add> .filter(v -> true)
<add> );
<add> }
<add>
<add> @Test
<add> public void transitiveBoundaryFusionNone() {
<add> @SuppressWarnings("unchecked")
<add> ConditionalSubscriber<Integer> ts = mock(ConditionalSubscriber.class);
<add>
<add> BasicFuseableConditionalSubscriber<Integer, Integer> bfs = new BasicFuseableConditionalSubscriber<Integer, Integer>(ts) {
<add>
<add> @Override
<add> protected boolean beforeDownstream() {
<add> return false;
<add> }
<add>
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> ts.onNext(t);
<add> }
<add>
<add> @Override
<add> public int requestFusion(int mode) {
<add> // TODO Auto-generated method stub
<add> return 0;
<add> }
<add>
<add> @Override
<add> public boolean tryOnNext(@NonNull Integer t) {
<add> // TODO Auto-generated method stub
<add> return false;
<add> }
<add>
<add> @Override
<add> public @Nullable Integer poll() throws Throwable {
<add> return null;
<add> }
<add> };
<add>
<add> bfs.onSubscribe(new BooleanSubscription());
<add>
<add> assertEquals(QueueFuseable.NONE, bfs.transitiveBoundaryFusion(QueueFuseable.ANY));
<add> }
<add>
<add> @Test
<add> public void transitiveBoundaryFusionAsync() {
<add> @SuppressWarnings("unchecked")
<add> ConditionalSubscriber<Integer> ts = mock(ConditionalSubscriber.class);
<add>
<add> BasicFuseableConditionalSubscriber<Integer, Integer> bfs = new BasicFuseableConditionalSubscriber<Integer, Integer>(ts) {
<add>
<add> @Override
<add> protected boolean beforeDownstream() {
<add> return false;
<add> }
<add>
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> ts.onNext(t);
<add> }
<add>
<add> @Override
<add> public int requestFusion(int mode) {
<add> // TODO Auto-generated method stub
<add> return 0;
<add> }
<add>
<add> @Override
<add> public boolean tryOnNext(@NonNull Integer t) {
<add> // TODO Auto-generated method stub
<add> return false;
<add> }
<add>
<add> @Override
<add> public @Nullable Integer poll() throws Throwable {
<add> return null;
<add> }
<add> };
<add>
<add> bfs.onSubscribe(EmptySubscription.INSTANCE);
<add>
<add> assertEquals(QueueFuseable.ASYNC, bfs.transitiveBoundaryFusion(QueueFuseable.ANY));
<add> }
<add>
<add> @Test
<add> public void transitiveBoundaryFusionAsyncBoundary() {
<add> @SuppressWarnings("unchecked")
<add> ConditionalSubscriber<Integer> ts = mock(ConditionalSubscriber.class);
<add>
<add> BasicFuseableConditionalSubscriber<Integer, Integer> bfs = new BasicFuseableConditionalSubscriber<Integer, Integer>(ts) {
<add>
<add> @Override
<add> protected boolean beforeDownstream() {
<add> return false;
<add> }
<add>
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> ts.onNext(t);
<add> }
<add>
<add> @Override
<add> public int requestFusion(int mode) {
<add> // TODO Auto-generated method stub
<add> return 0;
<add> }
<add>
<add> @Override
<add> public boolean tryOnNext(@NonNull Integer t) {
<add> // TODO Auto-generated method stub
<add> return false;
<add> }
<add>
<add> @Override
<add> public @Nullable Integer poll() throws Throwable {
<add> return null;
<add> }
<add> };
<add>
<add> bfs.onSubscribe(EmptySubscription.INSTANCE);
<add>
<add> assertEquals(QueueFuseable.NONE, bfs.transitiveBoundaryFusion(QueueFuseable.ANY | QueueFuseable.BOUNDARY));
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/subscribers/BasicFuseableSubscriberTest.java
<ide>
<ide> import org.junit.Test;
<ide>
<del>import io.reactivex.rxjava3.annotations.Nullable;
<add>import io.reactivex.rxjava3.annotations.*;
<ide> import io.reactivex.rxjava3.core.RxJavaTest;
<del>import io.reactivex.rxjava3.internal.subscriptions.ScalarSubscription;
<add>import io.reactivex.rxjava3.internal.subscriptions.*;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide>
<ide> public Integer poll() throws Exception {
<ide> fcs.clear();
<ide> assertTrue(fcs.isEmpty());
<ide> }
<add>
<add> @Test
<add> public void implementationStopsOnSubscribe() {
<add> TestSubscriber<Integer> ts = new TestSubscriber<>();
<add> BasicFuseableSubscriber<Integer, Integer> bfs = new BasicFuseableSubscriber<Integer, Integer>(ts) {
<add>
<add> @Override
<add> protected boolean beforeDownstream() {
<add> return false;
<add> }
<add>
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> ts.onNext(t);
<add> }
<add>
<add> @Override
<add> public int requestFusion(int mode) {
<add> // TODO Auto-generated method stub
<add> return 0;
<add> }
<add>
<add> @Override
<add> public @Nullable Integer poll() throws Throwable {
<add> return null;
<add> }
<add> };
<add>
<add> bfs.onSubscribe(new BooleanSubscription());
<add>
<add> assertFalse(ts.hasSubscription());
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/subscribers/BoundedSubscriberTest.java
<ide> public void customOnErrorShouldReportCustomOnError() {
<ide>
<ide> assertTrue(subscriber.hasCustomOnError());
<ide> }
<add>
<add> @Test
<add> public void cancel() {
<add> BoundedSubscriber<Integer> subscriber = new BoundedSubscriber<>(Functions.<Integer>emptyConsumer(),
<add> Functions.<Throwable>emptyConsumer(),
<add> Functions.EMPTY_ACTION,
<add> Functions.<Subscription>boundedConsumer(128), 128);
<add>
<add> BooleanSubscription bs = new BooleanSubscription();
<add> subscriber.onSubscribe(bs);
<add>
<add> subscriber.cancel();
<add>
<add> assertTrue(bs.isCancelled());
<add> }
<add>
<add> @Test
<add> public void dispose() {
<add> BoundedSubscriber<Integer> subscriber = new BoundedSubscriber<>(Functions.<Integer>emptyConsumer(),
<add> Functions.<Throwable>emptyConsumer(),
<add> Functions.EMPTY_ACTION,
<add> Functions.<Subscription>boundedConsumer(128), 128);
<add>
<add> BooleanSubscription bs = new BooleanSubscription();
<add> subscriber.onSubscribe(bs);
<add>
<add> assertFalse(subscriber.isDisposed());
<add>
<add> subscriber.dispose();
<add>
<add> assertTrue(bs.isCancelled());
<add> assertTrue(subscriber.isDisposed());
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/subscribers/FutureSubscriberTest.java
<ide> public void getTimedOut() throws Exception {
<ide> assertEquals(timeoutMessage(1, TimeUnit.NANOSECONDS), expected.getMessage());
<ide> }
<ide> }
<add>
<add> @Test
<add> public void onNextCompleteOnError() throws Exception {
<add> List<Throwable> errors = TestHelper.trackPluginErrors();
<add> try {
<add> fs.onNext(1);
<add> fs.onComplete();
<add> fs.onError(new TestException("One"));
<add>
<add> assertEquals((Integer)1, fs.get(5, TimeUnit.MILLISECONDS));
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> } finally {
<add> RxJavaPlugins.reset();
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/internal/util/MiscUtilTest.java
<ide> public void errorModeEnum() {
<ide> @Test
<ide> public void linkedArrayList() {
<ide> LinkedArrayList list = new LinkedArrayList(2);
<add> assertEquals(0, list.size());
<ide> list.add(1);
<add> assertEquals(1, list.size());
<ide> list.add(2);
<add> assertEquals(2, list.size());
<ide> list.add(3);
<add> assertEquals(3, list.size());
<ide> assertEquals("[1, 2, 3]", list.toString());
<ide> }
<ide>
<ide><path>src/test/java/io/reactivex/rxjava3/observers/SerializedObserverTest.java
<ide> import org.junit.*;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.internal.util.ExceptionHelper;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> public void nullOnNext() {
<ide>
<ide> to.assertFailureAndMessage(NullPointerException.class, ExceptionHelper.nullWarning("onNext called with a null value."));
<ide> }
<add>
<add> @Test
<add> public void onErrorQueuedUp() {
<add> AtomicReference<SerializedObserver<Integer>> soRef = new AtomicReference<>();
<add> TestObserverEx<Integer> to = new TestObserverEx<Integer>() {
<add> @Override
<add> public void onNext(Integer t) {
<add> super.onNext(t);
<add> soRef.get().onNext(2);
<add> soRef.get().onError(new TestException());
<add> }
<add> };
<add>
<add> final SerializedObserver<Integer> so = new SerializedObserver<>(to, true);
<add> soRef.set(so);
<add>
<add> Disposable d = Disposable.empty();
<add>
<add> so.onSubscribe(d);
<add>
<add> so.onNext(1);
<add>
<add> to.assertFailure(TestException.class, 1, 2);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/observers/TestObserverTest.java
<ide> public void assertValuesOnlyThrowsWhenErrored() {
<ide> // expected
<ide> }
<ide> }
<add>
<add> @Test
<add> public void onErrorIsNull() {
<add> TestObserver<Integer> to = TestObserver.create();
<add> to.onSubscribe(Disposable.empty());
<add>
<add> to.onError(null);
<add>
<add> to.assertFailure(NullPointerException.class);
<add> }
<add>
<add> @Test
<add> public void awaitCountTimeout() {
<add> TestObserver<Integer> to = TestObserver.create();
<add> to.onSubscribe(Disposable.empty());
<add> to.awaitCount(1);
<add> assertTrue(to.timeout);
<add> }
<add>
<add> @Test(expected = RuntimeException.class)
<add> public void awaitCountInterrupted() {
<add> try {
<add> TestObserver<Integer> to = TestObserver.create();
<add> to.onSubscribe(Disposable.empty());
<add> Thread.currentThread().interrupt();
<add> to.awaitCount(1);
<add> } finally {
<add> Thread.interrupted();
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelCollectTest.java
<ide> public void accept(List<Object> a, Object b) throws Exception {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeParallel(
<add> pf -> pf.collect(ArrayList::new, ArrayList::add)
<add> );
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelDoOnNextTryTest.java
<ide> public void filterInvalidSourceConditional() {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f ->
<add> ParallelFlowable.fromArray(f)
<add> .doOnNext(v -> { }, ParallelFailureHandling.SKIP)
<add> .sequential()
<add> );
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribeConditional() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f ->
<add> ParallelFlowable.fromArray(f)
<add> .doOnNext(v -> { }, ParallelFailureHandling.SKIP)
<add> .filter(v -> true, ParallelFailureHandling.SKIP)
<add> .sequential()
<add> );
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelFilterTest.java
<ide> public boolean test(Integer v) throws Exception {
<ide> .test()
<ide> .assertFailure(TestException.class);
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f ->
<add> ParallelFlowable.fromArray(f)
<add> .filter(v -> true)
<add> .sequential()
<add> );
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribeConditional() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f ->
<add> ParallelFlowable.fromArray(f)
<add> .filter(v -> true)
<add> .filter(v -> true)
<add> .sequential()
<add> );
<add> }
<add>
<add> @Test
<add> public void conditionalFalseTrue() {
<add> Flowable.just(1)
<add> .parallel()
<add> .filter(v -> false)
<add> .filter(v -> true)
<add> .sequential()
<add> .test()
<add> .assertResult();
<add> }
<add>
<add> @Test
<add> public void conditionalTrueFalse() {
<add> Flowable.just(1)
<add> .parallel()
<add> .filter(v -> true)
<add> .filter(v -> false)
<add> .sequential()
<add> .test()
<add> .assertResult();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelFilterTryTest.java
<ide> public void filterInvalidSourceConditional() {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f ->
<add> ParallelFlowable.fromArray(f)
<add> .filter(v -> true, ParallelFailureHandling.SKIP)
<add> .sequential()
<add> );
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribeConditional() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f ->
<add> ParallelFlowable.fromArray(f)
<add> .filter(v -> true, ParallelFailureHandling.SKIP)
<add> .filter(v -> true, ParallelFailureHandling.SKIP)
<add> .sequential()
<add> );
<add> }
<add>
<add> @Test
<add> public void conditionalFalseTrue() {
<add> Flowable.just(1)
<add> .parallel()
<add> .filter(v -> false, ParallelFailureHandling.SKIP)
<add> .filter(v -> true, ParallelFailureHandling.SKIP)
<add> .sequential()
<add> .test()
<add> .assertResult();
<add> }
<add>
<add> @Test
<add> public void conditionalTrueFalse() {
<add> Flowable.just(1)
<add> .parallel()
<add> .filter(v -> true, ParallelFailureHandling.SKIP)
<add> .filter(v -> false, ParallelFailureHandling.SKIP)
<add> .sequential()
<add> .test()
<add> .assertResult();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelFlatMapIterableTest.java
<ide> package io.reactivex.rxjava3.parallel;
<ide>
<ide> import java.util.Arrays;
<del>import java.util.stream.Stream;
<ide>
<ide> import org.junit.Test;
<ide>
<ide> public class ParallelFlatMapIterableTest extends RxJavaTest {
<ide> @Test
<ide> public void subscriberCount() {
<ide> ParallelFlowableTest.checkSubscriberCount(Flowable.range(1, 5).parallel()
<del> .flatMapStream(v -> Stream.of(1, 2, 3)));
<add> .flatMapIterable(v -> Arrays.asList(1, 2, 3)));
<ide> }
<ide>
<ide> @Test
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelFromPublisherTest.java
<ide> import org.junit.Test;
<ide> import org.reactivestreams.*;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.fuseable.*;
<ide> import io.reactivex.rxjava3.internal.subscribers.BasicFuseableSubscriber;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<del>import io.reactivex.rxjava3.processors.UnicastProcessor;
<add>import io.reactivex.rxjava3.processors.*;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public Object apply(Integer v) throws Exception {
<ide> assertTrue(map.toString(), e.contains("RxComputationThreadPool"));
<ide> }
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(PublishProcessor.create().parallel());
<add> }
<add>
<add> @Test
<add> public void syncFusedEmptyPoll() {
<add> Flowable.just(1, 2)
<add> .filter(v -> v == 1)
<add> .compose(TestHelper.flowableStripBoundary())
<add> .parallel(1)
<add> .sequential()
<add> .test()
<add> .assertResult(1);
<add> }
<add>
<add> @Test
<add> public void asyncFusedEmptyPoll() {
<add> UnicastProcessor<Integer> up = UnicastProcessor.create();
<add> up.onNext(1);
<add> up.onNext(2);
<add> up.onComplete();
<add>
<add> up
<add> .filter(v -> v == 1)
<add> .compose(TestHelper.flowableStripBoundary())
<add> .parallel(1)
<add> .sequential()
<add> .test()
<add> .assertResult(1);
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f -> f.parallel().sequential());
<add> }
<add>
<add> @SuppressWarnings("unchecked")
<add> @Test
<add> public void requestUnboundedRace() {
<add> FlowableSubscriber<Integer> fs = new FlowableSubscriber<Integer>() {
<add>
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> }
<add>
<add> @Override
<add> public void onError(Throwable t) {
<add> }
<add>
<add> @Override
<add> public void onComplete() {
<add> }
<add>
<add> @Override
<add> public void onSubscribe(@NonNull Subscription s) {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> TestHelper.race(
<add> () -> s.request(Long.MAX_VALUE),
<add> () -> s.request(Long.MAX_VALUE)
<add> );
<add> }
<add> }
<add> };
<add>
<add> PublishProcessor.create()
<add> .parallel(1)
<add> .subscribe(new FlowableSubscriber[] { fs });
<add> }
<add>
<add> @SuppressWarnings("unchecked")
<add> @Test
<add> public void requestRace() {
<add> FlowableSubscriber<Integer> fs = new FlowableSubscriber<Integer>() {
<add>
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> }
<add>
<add> @Override
<add> public void onError(Throwable t) {
<add> }
<add>
<add> @Override
<add> public void onComplete() {
<add> }
<add>
<add> @Override
<add> public void onSubscribe(@NonNull Subscription s) {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> TestHelper.race(
<add> () -> s.request(1),
<add> () -> s.request(1)
<add> );
<add> }
<add> }
<add> };
<add>
<add> PublishProcessor.create()
<add> .parallel(1)
<add> .subscribe(new FlowableSubscriber[] { fs });
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelJoinTest.java
<ide> package io.reactivex.rxjava3.parallel;
<ide>
<ide> import java.util.List;
<add>import java.util.concurrent.atomic.AtomicReference;
<ide>
<ide> import org.junit.Test;
<ide> import org.reactivestreams.Subscriber;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.*;
<ide> import io.reactivex.rxjava3.functions.Function;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<add>import io.reactivex.rxjava3.processors.PublishProcessor;
<ide> import io.reactivex.rxjava3.subscribers.TestSubscriber;
<ide> import io.reactivex.rxjava3.testsupport.*;
<ide>
<ide> public Integer apply(Integer v) throws Exception {
<ide> .test()
<ide> .assertFailure(TestException.class, 2, 3, 4);
<ide> }
<add>
<add> @Test
<add> public void takeUntil() {
<add> Flowable.range(1, 10)
<add> .parallel(1)
<add> .sequential()
<add> .takeUntil(v -> true)
<add> .test(0L)
<add> .requestMore(100)
<add> .assertResult(1);
<add> }
<add>
<add> @Test
<add> public void takeUntilDelayError() {
<add> Flowable.range(1, 10)
<add> .parallel(1)
<add> .sequentialDelayError()
<add> .takeUntil(v -> true)
<add> .test(0L)
<add> .requestMore(100)
<add> .assertResult(1);
<add> }
<add>
<add> @Test
<add> public void oneItemNext() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = pp.parallel(1)
<add> .sequential()
<add> .test(0L);
<add>
<add> pp.onNext(1);
<add>
<add> ts.requestMore(10)
<add> .assertValuesOnly(1);
<add> }
<add>
<add> @Test
<add> public void delayErrorOneItemNext() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = pp.parallel(1)
<add> .sequentialDelayError()
<add> .test(0L);
<add>
<add> pp.onNext(1);
<add>
<add> ts.requestMore(10)
<add> .assertValuesOnly(1);
<add> }
<add>
<add> @Test
<add> public void onNextWhileProcessingSlowPath() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> super.onNext(t);
<add> if (t == 1) {
<add> pp.onNext(2);
<add> }
<add> }
<add> };
<add>
<add> ParallelFlowable.fromArray(pp)
<add> .sequential()
<add> .subscribeWith(ts);
<add>
<add> pp.onNext(1);
<add>
<add> ts
<add> .assertValuesOnly(1, 2);
<add> }
<add>
<add> @Test
<add> public void delayErrorOnNextWhileProcessingSlowPath() {
<add> PublishProcessor<Integer> pp = PublishProcessor.create();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> super.onNext(t);
<add> if (t == 1) {
<add> pp.onNext(2);
<add> }
<add> }
<add> };
<add>
<add> ParallelFlowable.fromArray(pp)
<add> .sequentialDelayError()
<add> .subscribeWith(ts);
<add>
<add> pp.onNext(1);
<add>
<add> ts
<add> .assertValuesOnly(1, 2);
<add> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(
<add> ParallelFlowable.fromArray(PublishProcessor.create())
<add> .sequential()
<add> );
<add> }
<add>
<add> @Test
<add> public void onNextMissingBackpressureRace() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add>
<add> AtomicReference<Subscriber<? super Integer>> ref1 = new AtomicReference<>();
<add> AtomicReference<Subscriber<? super Integer>> ref2 = new AtomicReference<>();
<add>
<add> Flowable<Integer> f1 = new Flowable<Integer>() {
<add> @Override
<add> public void subscribeActual(Subscriber<? super Integer> s) {
<add> s.onSubscribe(new BooleanSubscription());
<add> ref1.set(s);
<add> }
<add> };
<add> Flowable<Integer> f2 = new Flowable<Integer>() {
<add> @Override
<add> public void subscribeActual(Subscriber<? super Integer> s) {
<add> s.onSubscribe(new BooleanSubscription());
<add> ref2.set(s);
<add> }
<add> };
<add>
<add> ParallelFlowable.fromArray(f1, f2)
<add> .sequential(1)
<add> .test(0)
<add> ;
<add>
<add> TestHelper.race(
<add> () -> {
<add> ref1.get().onNext(1);
<add> ref1.get().onNext(2);
<add> },
<add> () -> {
<add> ref2.get().onNext(3);
<add> ref2.get().onNext(4);
<add> }
<add> );
<add>
<add> errors.clear();
<add> }
<add> });
<add> }
<add>
<add> @Test
<add> public void onNextMissingBackpressureDelayErrorRace() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add>
<add> AtomicReference<Subscriber<? super Integer>> ref1 = new AtomicReference<>();
<add> AtomicReference<Subscriber<? super Integer>> ref2 = new AtomicReference<>();
<add>
<add> Flowable<Integer> f1 = new Flowable<Integer>() {
<add> @Override
<add> public void subscribeActual(Subscriber<? super Integer> s) {
<add> s.onSubscribe(new BooleanSubscription());
<add> ref1.set(s);
<add> }
<add> };
<add> Flowable<Integer> f2 = new Flowable<Integer>() {
<add> @Override
<add> public void subscribeActual(Subscriber<? super Integer> s) {
<add> s.onSubscribe(new BooleanSubscription());
<add> ref2.set(s);
<add> }
<add> };
<add>
<add> ParallelFlowable.fromArray(f1, f2)
<add> .sequentialDelayError(1)
<add> .test(0)
<add> ;
<add>
<add> TestHelper.race(
<add> () -> {
<add> ref1.get().onNext(1);
<add> ref1.get().onNext(2);
<add> },
<add> () -> {
<add> ref2.get().onNext(3);
<add> ref2.get().onNext(4);
<add> }
<add> );
<add>
<add> errors.clear();
<add> }
<add> });
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelMapTest.java
<ide>
<ide> import static org.junit.Assert.*;
<ide>
<del>import java.util.*;
<add>import java.util.List;
<ide> import java.util.concurrent.TimeUnit;
<ide>
<ide> import org.junit.Test;
<add>import org.reactivestreams.Subscriber;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<add>import io.reactivex.rxjava3.internal.fuseable.ConditionalSubscriber;
<add>import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> import io.reactivex.rxjava3.testsupport.TestHelper;
<ide> public void doubleOnSubscribe() {
<ide> .filter(v -> true)
<ide> );
<ide> }
<add>
<add> @Test
<add> public void conditionalCancelIgnored() {
<add> Flowable<Integer> f = new Flowable<Integer>() {
<add> @Override
<add> protected void subscribeActual(@NonNull Subscriber<@NonNull ? super @NonNull Integer> s) {
<add> @SuppressWarnings("unchecked")
<add> ConditionalSubscriber<Integer> subscriber = (ConditionalSubscriber<Integer>)s;
<add> subscriber.onSubscribe(new BooleanSubscription());
<add> subscriber.tryOnNext(1);
<add> subscriber.tryOnNext(2);
<add> }
<add> };
<add>
<add> ParallelFlowable.fromArray(f)
<add> .map(v -> { throw new TestException(); })
<add> .filter(v -> true)
<add> .sequential()
<add> .test()
<add> .assertFailure(TestException.class);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelPeekTest.java
<ide> public void run() throws Exception {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeFlowable(f ->
<add> ParallelFlowable.fromArray(f)
<add> .doOnComplete(() -> { })
<add> .sequential()
<add> );
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelReduceFullTest.java
<ide> import static org.junit.Assert.*;
<ide>
<ide> import java.io.IOException;
<del>import java.util.List;
<add>import java.util.*;
<ide>
<ide> import org.junit.Test;
<ide>
<ide> public Integer apply(Integer a, Integer b) throws Exception {
<ide> .test()
<ide> .assertFailure(TestException.class);
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeParallelToFlowable(
<add> pf -> pf.reduce((a, b) -> a)
<add> );
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelReduceTest.java
<ide> public List<Object> apply(List<Object> a, Object b) throws Exception {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeParallel(
<add> pf -> pf.reduce(ArrayList::new, (a, b) -> a)
<add> );
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelRunOnTest.java
<ide> public void onNext(Integer t) {
<ide>
<ide> ts.assertResult(1);
<ide> }
<add>
<add> @Test
<add> public void doubleOnSubscribe() {
<add> TestHelper.checkDoubleOnSubscribeParallel(pf -> pf.runOn(ImmediateThinScheduler.INSTANCE));
<add> }
<add>
<add> @Test
<add> public void doubleOnSubscribeConditional() {
<add> TestHelper.checkDoubleOnSubscribeParallel(pf ->
<add> pf.runOn(ImmediateThinScheduler.INSTANCE)
<add> .filter(v -> true)
<add> );
<add> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(
<add> ParallelFlowable.fromArray(PublishProcessor.create())
<add> .runOn(ImmediateThinScheduler.INSTANCE)
<add> );
<add> }
<add>
<add> @SuppressWarnings("unchecked")
<add> @Test
<add> public void asManyItemsAsRequested() {
<add> TestSubscriber<Integer> ts = new TestSubscriber<>(0);
<add>
<add> Flowable.range(1, 5)
<add> .parallel(1)
<add> .runOn(ImmediateThinScheduler.INSTANCE)
<add> .subscribe(new Subscriber[] {
<add> ts
<add> });
<add>
<add> ts
<add> .requestMore(5)
<add> .assertResult(1, 2, 3, 4, 5);
<add> }
<add>
<add> @SuppressWarnings("unchecked")
<add> @Test
<add> public void asManyItemsAsRequestedConditional() {
<add> TestSubscriber<Integer> ts = new TestSubscriber<>(0);
<add>
<add> Flowable.range(1, 5)
<add> .parallel(1)
<add> .runOn(ImmediateThinScheduler.INSTANCE)
<add> .filter(v -> true)
<add> .subscribe(new Subscriber[] {
<add> ts
<add> });
<add>
<add> ts
<add> .requestMore(5)
<add> .assertResult(1, 2, 3, 4, 5);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/parallel/ParallelSortedJoinTest.java
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<add>import io.reactivex.rxjava3.internal.operators.parallel.ParallelSortedJoin;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> import io.reactivex.rxjava3.processors.*;
<ide> import io.reactivex.rxjava3.schedulers.Schedulers;
<ide> public void run() {
<ide> TestHelper.race(r1, r2);
<ide> }
<ide> }
<add>
<add> @Test
<add> public void badRequest() {
<add> TestHelper.assertBadRequestReported(PublishProcessor.<Integer>create().parallel().sorted(Functions.naturalComparator()));
<add> }
<add>
<add> @Test
<add> public void comparatorCrashWhileMainOnError() throws Throwable {
<add> TestHelper.withErrorTracking(errors -> {
<add> PublishProcessor<List<Integer>> pp1 = PublishProcessor.create();
<add> PublishProcessor<List<Integer>> pp2 = PublishProcessor.create();
<add>
<add> new ParallelSortedJoin<>(ParallelFlowable.fromArray(pp1, pp2)
<add> , (a, b) -> {
<add> pp1.onError(new IOException());
<add> throw new TestException();
<add> })
<add> .test();
<add>
<add> pp1.onNext(Arrays.asList(1));
<add> pp2.onNext(Arrays.asList(2));
<add>
<add> pp1.onComplete();
<add> pp2.onComplete();
<add>
<add> TestHelper.assertUndeliverable(errors, 0, TestException.class);
<add> });
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/processors/AsyncProcessorTest.java
<ide> public void onComplete() {
<ide> ts1.assertResult();
<ide> ts2.assertEmpty();
<ide> }
<add>
<add> @Test
<add> public void cancel() {
<add> TestHelper.checkDisposed(AsyncProcessor.create());
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/processors/BehaviorProcessorTest.java
<ide> public void run() {
<ide> }
<ide> }
<ide>
<add> @Test
<add> public void multipleSubscribersRemoveSomeRace() {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> final BehaviorProcessor<Object> p = BehaviorProcessor.create();
<add>
<add> final TestSubscriber<Object> ts1 = p.test();
<add> final TestSubscriber<Object> ts2 = p.test();
<add> final TestSubscriber<Object> ts3 = p.test();
<add>
<add> Runnable r1 = new Runnable() {
<add> @Override
<add> public void run() {
<add> ts1.cancel();
<add> }
<add> };
<add>
<add> Runnable r2 = new Runnable() {
<add> @Override
<add> public void run() {
<add> ts2.cancel();
<add> }
<add> };
<add>
<add> TestHelper.race(r1, r2);
<add>
<add> p.onNext(1);
<add> ts3.assertValuesOnly(1);
<add> }
<add> }
<add>
<ide> @SuppressWarnings({ "rawtypes", "unchecked" })
<ide> @Test
<ide> public void subscribeOnNextRace() {
<ide><path>src/test/java/io/reactivex/rxjava3/processors/ReplayProcessorTest.java
<ide> import org.mockito.*;
<ide> import org.reactivestreams.*;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.Flowable;
<ide> import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> public void takeSizeAndTime() {
<ide> .assertResult(2);
<ide> }
<ide>
<add> @Test
<add> public void takeSizeAndTime2() {
<add> TestScheduler scheduler = new TestScheduler();
<add>
<add> ReplayProcessor<Integer> rp = ReplayProcessor.createWithTimeAndSize(1, TimeUnit.SECONDS, scheduler, 2);
<add>
<add> rp.onNext(1);
<add> rp.onNext(2);
<add> rp.onNext(3);
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> super.onNext(t);
<add> cancel();
<add> onComplete();
<add> }
<add> };
<add>
<add> rp
<add> .subscribeWith(ts)
<add> .assertResult(2);
<add> }
<add>
<ide> @Test
<ide> public void takeSize() {
<ide> ReplayProcessor<Integer> rp = ReplayProcessor.createWithSize(2);
<ide> public void takeSize() {
<ide> .assertResult(2);
<ide> }
<ide>
<add> @Test
<add> public void takeSize2() {
<add> ReplayProcessor<Integer> rp = ReplayProcessor.createWithSize(2);
<add>
<add> rp.onNext(1);
<add> rp.onNext(2);
<add> rp.onNext(3);
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> super.onNext(t);
<add> cancel();
<add> onComplete();
<add> }
<add> };
<add>
<add> rp
<add> .subscribeWith(ts)
<add> .assertResult(2);
<add> }
<add>
<ide> @Test
<ide> public void reentrantDrain() {
<ide> TestScheduler scheduler = new TestScheduler();
<ide><path>src/test/java/io/reactivex/rxjava3/processors/SerializedProcessorTest.java
<ide>
<ide> import org.junit.Test;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<ide> public void run() {
<ide> ts.assertEmpty();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void onErrorQueued() {
<add> FlowableProcessor<Integer> sp = PublishProcessor.<Integer>create().toSerialized();
<add>
<add> TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> super.onNext(t);
<add> if (t == 1) {
<add> sp.onNext(2);
<add> sp.onSubscribe(new BooleanSubscription());
<add> sp.onError(new TestException());
<add> }
<add> }
<add> };
<add>
<add> sp.subscribe(ts);
<add>
<add> sp.onNext(1);
<add>
<add> ts.assertFailure(TestException.class, 1); // errors skip ahead
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/schedulers/ExecutorSchedulerTest.java
<ide> import java.lang.management.*;
<ide> import java.util.List;
<ide> import java.util.concurrent.*;
<del>import java.util.concurrent.atomic.AtomicInteger;
<add>import java.util.concurrent.atomic.*;
<ide>
<ide> import org.junit.Test;
<ide>
<ide> import io.reactivex.rxjava3.core.Scheduler;
<ide> import io.reactivex.rxjava3.core.Scheduler.Worker;
<ide> import io.reactivex.rxjava3.disposables.Disposable;
<del>import io.reactivex.rxjava3.internal.disposables.EmptyDisposable;
<add>import io.reactivex.rxjava3.internal.disposables.*;
<ide> import io.reactivex.rxjava3.internal.functions.Functions;
<ide> import io.reactivex.rxjava3.internal.schedulers.*;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> public void run() {
<ide>
<ide> assertSame(Functions.EMPTY_RUNNABLE, wrapper.getWrappedRunnable());
<ide> }
<add>
<add> @Test
<add> public void interruptibleRunnableRunDisposeRace() {
<add> ExecutorService exec = Executors.newSingleThreadExecutor();
<add> try {
<add> Scheduler s = Schedulers.from(r -> exec.execute(r), true);
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> SequentialDisposable sd = new SequentialDisposable();
<add>
<add> TestHelper.race(
<add> () -> sd.update(s.scheduleDirect(() -> { })),
<add> () -> sd.dispose()
<add> );
<add> }
<add> } finally {
<add> exec.shutdown();
<add> }
<add> }
<add>
<add> @Test
<add> public void interruptibleRunnableRunDispose() {
<add> try {
<add> for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
<add> AtomicReference<Runnable> runRef = new AtomicReference<>();
<add> Scheduler s = Schedulers.from(r -> {
<add> runRef.set(r);
<add> }, true);
<add>
<add> Disposable d = s.scheduleDirect(() -> { });
<add> TestHelper.race(
<add> () -> runRef.get().run(),
<add> () -> d.dispose()
<add> );
<add> }
<add> } finally {
<add> Thread.interrupted();
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/subjects/AsyncSubjectTest.java
<ide> import org.mockito.*;
<ide>
<ide> import io.reactivex.rxjava3.core.Observer;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.functions.Consumer;
<ide> import io.reactivex.rxjava3.internal.fuseable.QueueFuseable;
<ide> public void onComplete() {
<ide> to1.assertResult();
<ide> to2.assertEmpty();
<ide> }
<add>
<add> @Test
<add> public void dispose() {
<add> TestHelper.checkDisposed(AsyncSubject.create());
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/subjects/BehaviorSubjectTest.java
<ide> public void emittingEmitNext() {
<ide>
<ide> assertNotNull(bd.queue);
<ide> }
<add>
<add> @Test
<add> public void hasObservers() {
<add> BehaviorSubject<Integer> bs = BehaviorSubject.create();
<add>
<add> assertFalse(bs.hasObservers());
<add>
<add> TestObserver<Integer> to = bs.test();
<add>
<add> assertTrue(bs.hasObservers());
<add>
<add> to.dispose();
<add>
<add> assertFalse(bs.hasObservers());
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/subjects/SerializedSubjectTest.java
<ide>
<ide> import org.junit.Test;
<ide>
<add>import io.reactivex.rxjava3.annotations.NonNull;
<ide> import io.reactivex.rxjava3.core.Observable;
<ide> import io.reactivex.rxjava3.core.RxJavaTest;
<del>import io.reactivex.rxjava3.disposables.*;
<add>import io.reactivex.rxjava3.disposables.Disposable;
<ide> import io.reactivex.rxjava3.exceptions.TestException;
<ide> import io.reactivex.rxjava3.observers.TestObserver;
<ide> import io.reactivex.rxjava3.plugins.RxJavaPlugins;
<ide> public void run() {
<ide> to.assertEmpty();
<ide> }
<ide> }
<add>
<add> @Test
<add> public void onErrorQueued() {
<add> Subject<Integer> sp = PublishSubject.<Integer>create().toSerialized();
<add>
<add> TestObserver<Integer> to = new TestObserver<Integer>() {
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> super.onNext(t);
<add> if (t == 1) {
<add> sp.onNext(2);
<add> sp.onNext(3);
<add> sp.onSubscribe(Disposable.empty());
<add> sp.onError(new TestException());
<add> }
<add> }
<add> };
<add>
<add> sp.subscribe(to);
<add>
<add> sp.onNext(1);
<add>
<add> to.assertFailure(TestException.class, 1); // errors skip ahead
<add> }
<add>
<add> @Test
<add> public void onCompleteQueued() {
<add> Subject<Integer> sp = PublishSubject.<Integer>create().toSerialized();
<add>
<add> TestObserver<Integer> to = new TestObserver<Integer>() {
<add> @Override
<add> public void onNext(@NonNull Integer t) {
<add> super.onNext(t);
<add> if (t == 1) {
<add> sp.onNext(2);
<add> sp.onNext(3);
<add> sp.onComplete();
<add> }
<add> }
<add> };
<add>
<add> sp.subscribe(to);
<add>
<add> sp.onNext(1);
<add>
<add> to.assertResult(1, 2, 3);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/subjects/UnicastSubjectTest.java
<ide> public void fusedNoConcurrentCleanDueToCancel() {
<ide> }
<ide> }
<ide> }
<add>
<add> @Test
<add> public void withCapacityHint() {
<add> UnicastSubject<Integer> us = UnicastSubject.create(16);
<add>
<add> TestObserver<Integer> to = us.test();
<add>
<add> for (int i = 0; i < 256; i++) {
<add> us.onNext(i);
<add> }
<add> us.onComplete();
<add>
<add> to.assertValueCount(256)
<add> .assertComplete()
<add> .assertNoErrors();
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/subscribers/SerializedSubscriberTest.java
<ide> public void nullOnNext() {
<ide>
<ide> ts.assertFailureAndMessage(NullPointerException.class, ExceptionHelper.nullWarning("onNext called with a null value."));
<ide> }
<add>
<add> @Test
<add> public void onErrorQueuedUp() {
<add> AtomicReference<SerializedSubscriber<Integer>> ssRef = new AtomicReference<>();
<add> TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>() {
<add> @Override
<add> public void onNext(Integer t) {
<add> super.onNext(t);
<add> ssRef.get().onNext(2);
<add> ssRef.get().onError(new TestException());
<add> }
<add> };
<add>
<add> final SerializedSubscriber<Integer> so = new SerializedSubscriber<>(ts, true);
<add> ssRef.set(so);
<add>
<add> BooleanSubscription bs = new BooleanSubscription();
<add>
<add> so.onSubscribe(bs);
<add>
<add> so.onNext(1);
<add>
<add> ts.assertFailure(TestException.class, 1, 2);
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/subscribers/TestSubscriberTest.java
<ide> public void assertValuesOnlyThrowsWhenErrored() {
<ide> // expected
<ide> }
<ide> }
<add>
<add> @Test
<add> public void onErrorIsNull() {
<add> TestSubscriber<Integer> ts = TestSubscriber.create();
<add> ts.onSubscribe(new BooleanSubscription());
<add>
<add> ts.onError(null);
<add>
<add> ts.assertFailure(NullPointerException.class);
<add> }
<add>
<add> static final class TestSubscriberImpl<T> extends TestSubscriber<T> {
<add> public boolean isTimeout() {
<add> return timeout;
<add> }
<add> }
<add>
<add> @Test
<add> public void awaitCountTimeout() {
<add> TestSubscriberImpl<Integer> ts = new TestSubscriberImpl<>();
<add> ts.onSubscribe(new BooleanSubscription());
<add> ts.awaitCount(1);
<add> assertTrue(ts.isTimeout());
<add> }
<add>
<add> @Test(expected = RuntimeException.class)
<add> public void awaitCountInterrupted() {
<add> try {
<add> TestSubscriber<Integer> ts = TestSubscriber.create();
<add> ts.onSubscribe(new BooleanSubscription());
<add> Thread.currentThread().interrupt();
<add> ts.awaitCount(1);
<add> } finally {
<add> Thread.interrupted();
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/testsupport/TestHelper.java
<ide> import org.mockito.stubbing.Answer;
<ide> import org.reactivestreams.*;
<ide>
<add>import io.reactivex.rxjava3.annotations.*;
<ide> import io.reactivex.rxjava3.core.*;
<ide> import io.reactivex.rxjava3.core.Observable;
<ide> import io.reactivex.rxjava3.core.Observer;
<ide> import io.reactivex.rxjava3.internal.operators.completable.CompletableToFlowable;
<ide> import io.reactivex.rxjava3.internal.operators.maybe.MaybeToFlowable;
<ide> import io.reactivex.rxjava3.internal.operators.single.SingleToFlowable;
<del>import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
<add>import io.reactivex.rxjava3.internal.subscriptions.*;
<ide> import io.reactivex.rxjava3.internal.util.ExceptionHelper;
<ide> import io.reactivex.rxjava3.observers.BaseTestConsumer;
<ide> import io.reactivex.rxjava3.parallel.ParallelFlowable;
<ide> public void onComplete() {
<ide> RxJavaPlugins.setErrorHandler(null);
<ide> }
<ide> }
<add>
<add> /**
<add> * Assert that by consuming the Publisher with a bad request amount, it is
<add> * reported to the plugin error handler promptly.
<add> * @param source the source to consume
<add> */
<add> public static void assertBadRequestReported(ParallelFlowable<?> source) {
<add> List<Throwable> list = trackPluginErrors();
<add> try {
<add> final CountDownLatch cdl = new CountDownLatch(1);
<add>
<add> FlowableSubscriber<Object> bad = new FlowableSubscriber<Object>() {
<add>
<add> @Override
<add> public void onSubscribe(Subscription s) {
<add> try {
<add> s.request(-99);
<add> s.cancel();
<add> s.cancel();
<add> } finally {
<add> cdl.countDown();
<add> }
<add> }
<add>
<add> @Override
<add> public void onNext(Object t) {
<add>
<add> }
<add>
<add> @Override
<add> public void onError(Throwable t) {
<add>
<add> }
<add>
<add> @Override
<add> public void onComplete() {
<add>
<add> }
<add>
<add> };
<add>
<add> @SuppressWarnings("unchecked")
<add> FlowableSubscriber<Object>[] subs = new FlowableSubscriber[source.parallelism()];
<add> subs[0] = bad;
<add> for (int i = 1; i < subs.length; i++) {
<add> subs[i] = NoOpConsumer.INSTANCE;
<add> }
<add> source.subscribe(subs);
<add>
<add> try {
<add> assertTrue(cdl.await(5, TimeUnit.SECONDS));
<add> } catch (InterruptedException ex) {
<add> throw new AssertionError(ex.getMessage());
<add> }
<add>
<add> assertTrue(list.toString(), list.get(0) instanceof IllegalArgumentException);
<add> assertEquals("n > 0 required but it was -99", list.get(0).getMessage());
<add> } finally {
<add> RxJavaPlugins.setErrorHandler(null);
<add> }
<add> }
<add>
<ide> /**
<ide> * Synchronizes the execution of two runnables (as much as possible)
<ide> * to test race conditions.
<ide> public static void doubleOnSubscribe(MaybeObserver<?> observer) {
<ide> }
<ide> }
<ide>
<add> public static void checkDisposed(Disposable d) {
<add> assertFalse("Disposed upfront?!", d.isDisposed());
<add>
<add> d.dispose();
<add>
<add> assertTrue("Not disposed?!", d.isDisposed());
<add>
<add> d.dispose();
<add>
<add> assertTrue("Not disposed again?!", d.isDisposed());
<add> }
<add>
<ide> /**
<ide> * Checks if the upstream's Subscription sent through the onSubscribe reports
<ide> * isCancelled properly before and after calling dispose.
<ide> public int parallelism() {
<ide> RxJavaPlugins.reset();
<ide> }
<ide> }
<add> /**
<add> * Check if the given transformed reactive type reports multiple onSubscribe calls to
<add> * RxJavaPlugins.
<add> * @param <T> the input value type
<add> * @param transform the transform to drive an operator
<add> */
<add> public static <T> void checkDoubleOnSubscribeParallelToFlowable(Function<ParallelFlowable<T>, ? extends Flowable<?>> transform) {
<add> List<Throwable> errors = trackPluginErrors();
<add> try {
<add> final Boolean[] b = { null, null, null, null };
<add> final CountDownLatch cdl = new CountDownLatch(2);
<add>
<add> ParallelFlowable<T> source = new ParallelFlowable<T>() {
<add> @Override
<add> public void subscribe(Subscriber<? super T>[] subscribers) {
<add> for (int i = 0; i < subscribers.length; i++) {
<add> try {
<add> BooleanSubscription bs1 = new BooleanSubscription();
<add>
<add> subscribers[i].onSubscribe(bs1);
<add>
<add> BooleanSubscription bs2 = new BooleanSubscription();
<add>
<add> subscribers[i].onSubscribe(bs2);
<add>
<add> b[i * 2 + 0] = bs1.isCancelled();
<add> b[i * 2 + 1] = bs2.isCancelled();
<add> } finally {
<add> cdl.countDown();
<add> }
<add> }
<add> }
<add>
<add> @Override
<add> public int parallelism() {
<add> return 2;
<add> }
<add> };
<add>
<add> Flowable<?> out = transform.apply(source);
<add>
<add> out.subscribe(NoOpConsumer.INSTANCE);
<add>
<add> try {
<add> assertTrue("Timed out", cdl.await(5, TimeUnit.SECONDS));
<add> } catch (InterruptedException ex) {
<add> throw ExceptionHelper.wrapOrThrow(ex);
<add> }
<add>
<add> assertEquals("Rail 1 First disposed?", false, b[0]);
<add> assertEquals("Rail 1 Second not disposed?", true, b[1]);
<add>
<add> assertEquals("Rail 2 First disposed?", false, b[2]);
<add> assertEquals("Rail 2 Second not disposed?", true, b[3]);
<add>
<add> assertError(errors, 0, IllegalStateException.class, "Subscription already set!");
<add> assertError(errors, 1, IllegalStateException.class, "Subscription already set!");
<add> } catch (Throwable ex) {
<add> throw ExceptionHelper.wrapOrThrow(ex);
<add> } finally {
<add> RxJavaPlugins.reset();
<add> }
<add> }
<ide>
<ide> /**
<ide> * Check if the given transformed reactive type reports multiple onSubscribe calls to
<ide> public static void assertError(CompletableFuture<?> cf, Class<? extends Throwabl
<ide> }
<ide> }
<ide> }
<add>
<add> /**
<add> * Syncs the execution of the given runnable with the execution of the
<add> * current thread.
<add> * @param run the other task to run in sync with the current thread
<add> * @param resume the latch to count down after the {@code run}
<add> */
<add> public static void raceOther(Runnable run, CountDownLatch resume) {
<add> AtomicInteger sync = new AtomicInteger(2);
<add>
<add> Schedulers.single().scheduleDirect(() -> {
<add> if (sync.decrementAndGet() != 0) {
<add> while (sync.get() != 0) { }
<add> }
<add>
<add> run.run();
<add>
<add> resume.countDown();
<add> });
<add>
<add> if (sync.decrementAndGet() != 0) {
<add> while (sync.get() != 0) { }
<add> }
<add> }
<add>
<add> /**
<add> * Inserts a ConditionalSubscriber into the chain to trigger the conditional paths
<add> * without interfering with the requestFusion parts.
<add> * @param <T> the element type
<add> * @return the new FlowableTransformer instance
<add> */
<add> public static <T> FlowableTransformer<T, T> conditional() {
<add> return f -> new Flowable<T>() {
<add> @Override
<add> protected void subscribeActual(@NonNull Subscriber<@NonNull ? super T> subscriber) {
<add> f.subscribe(new ForwardingConditionalSubscriber<>(subscriber));
<add> }
<add> };
<add> }
<add>
<add> /**
<add> * Wraps a Subscriber and exposes it as a fuseable conditional subscriber without interfering with
<add> * requestFusion.
<add> * @param <T> the element type
<add> */
<add> static final class ForwardingConditionalSubscriber<T> extends BasicQueueSubscription<T> implements ConditionalSubscriber<T> {
<add>
<add> private static final long serialVersionUID = 365317603608134078L;
<add>
<add> final Subscriber<? super T> downstream;
<add>
<add> Subscription upstream;
<add>
<add> QueueSubscription<T> qs;
<add>
<add> ForwardingConditionalSubscriber(Subscriber<? super T> downstream) {
<add> this.downstream = downstream;
<add> }
<add>
<add> @SuppressWarnings("unchecked")
<add> @Override
<add> public void onSubscribe(@NonNull Subscription s) {
<add> this.upstream = s;
<add> if (s instanceof QueueSubscription) {
<add> this.qs = (QueueSubscription<T>)s;
<add> }
<add> downstream.onSubscribe(this);
<add> }
<add>
<add> @Override
<add> public void onNext(@NonNull T t) {
<add> downstream.onNext(t);
<add> }
<add>
<add> @Override
<add> public boolean tryOnNext(@NonNull T t) {
<add> downstream.onNext(t);
<add> return true;
<add> }
<add>
<add> @Override
<add> public void onError(Throwable t) {
<add> downstream.onError(t);
<add> }
<add>
<add> @Override
<add> public void onComplete() {
<add> downstream.onComplete();
<add> }
<add>
<add> @Override
<add> public int requestFusion(int mode) {
<add> return qs != null ? qs.requestFusion(mode) : 0;
<add> }
<add>
<add> @Override
<add> public @Nullable T poll() throws Throwable {
<add> return qs.poll();
<add> }
<add>
<add> @Override
<add> public boolean isEmpty() {
<add> return qs.isEmpty();
<add> }
<add>
<add> @Override
<add> public void clear() {
<add> qs.clear();
<add> }
<add>
<add> @Override
<add> public void request(long n) {
<add> upstream.request(n);
<add> }
<add>
<add> @Override
<add> public void cancel() {
<add> upstream.cancel();
<add> }
<add> }
<ide> }
<ide><path>src/test/java/io/reactivex/rxjava3/validators/OperatorsUseInterfaces.java
<ide>
<ide> import java.lang.reflect.*;
<ide> import java.util.*;
<del>import java.util.Observable;
<ide> import java.util.concurrent.Callable;
<ide>
<ide> import org.junit.Test;
<ide> import org.reactivestreams.Publisher;
<ide>
<ide> import io.reactivex.rxjava3.core.*;
<add>import io.reactivex.rxjava3.core.Observable;
<ide> import io.reactivex.rxjava3.functions.*;
<ide> import io.reactivex.rxjava3.parallel.ParallelFlowable;
<ide> | 225 |
Python | Python | fix pmt test in numpy/lib/tests/test_financial.py | 97c481ee90459e8e372b74144f666cf06ad9df61 | <ide><path>numpy/lib/tests/test_financial.py
<ide>
<ide> import numpy as np
<ide> from numpy.testing import (
<del> run_module_suite, TestCase, assert_, assert_almost_equal
<add> run_module_suite, TestCase, assert_, assert_almost_equal,
<add> assert_allclose
<ide> )
<ide>
<ide>
<ide> def test_rate(self):
<ide>
<ide> def test_irr(self):
<ide> v = [-150000, 15000, 25000, 35000, 45000, 60000]
<del> assert_almost_equal(np.irr(v),
<del> 0.0524, 2)
<add> assert_almost_equal(np.irr(v), 0.0524, 2)
<ide> v = [-100, 0, 0, 74]
<del> assert_almost_equal(np.irr(v),
<del> -0.0955, 2)
<add> assert_almost_equal(np.irr(v), -0.0955, 2)
<ide> v = [-100, 39, 59, 55, 20]
<del> assert_almost_equal(np.irr(v),
<del> 0.28095, 2)
<add> assert_almost_equal(np.irr(v), 0.28095, 2)
<ide> v = [-100, 100, 0, -7]
<del> assert_almost_equal(np.irr(v),
<del> -0.0833, 2)
<add> assert_almost_equal(np.irr(v), -0.0833, 2)
<ide> v = [-100, 100, 0, 7]
<del> assert_almost_equal(np.irr(v),
<del> 0.06206, 2)
<add> assert_almost_equal(np.irr(v), 0.06206, 2)
<ide> v = [-5, 10.5, 1, -8, 1]
<del> assert_almost_equal(np.irr(v),
<del> 0.0886, 2)
<add> assert_almost_equal(np.irr(v), 0.0886, 2)
<ide>
<ide> def test_pv(self):
<del> assert_almost_equal(np.pv(0.07, 20, 12000, 0),
<del> -127128.17, 2)
<add> assert_almost_equal(np.pv(0.07, 20, 12000, 0), -127128.17, 2)
<ide>
<ide> def test_fv(self):
<del> assert_almost_equal(np.fv(0.075, 20, -2000, 0, 0),
<del> 86609.36, 2)
<add> assert_almost_equal(np.fv(0.075, 20, -2000, 0, 0), 86609.36, 2)
<ide>
<ide> def test_pmt(self):
<del> assert_almost_equal(np.pmt(0.08/12, 5*12, 15000),
<del> -304.146, 3)
<del> # This is to test the edge case where rate == 0.0
<del> # it would fail on this case if the fix for checking rate == 0.0 was not there
<del> assert_almost_equal(np.pmt(0.0, 5*12, 15000), -250.0, 3)
<del> # This one tests the case where we use broadcast and arguments passed in are arrays.
<del> assert_almost_equal(np.pmt([[0.0, 0.8],[0.3, 0.8]],[12, 3],[2000, 20000]), np.array([[-166.666, -19311.258],[-626.908, -19311.258]]), 3)
<add> res = np.pmt(0.08/12, 5*12, 15000)
<add> tgt = -304.145914
<add> assert_allclose(res, tgt)
<add> # Test the edge case where rate == 0.0
<add> res = np.pmt(0.0, 5*12, 15000)
<add> tgt = -250.0
<add> assert_allclose(res, tgt)
<add> # Test the case where we use broadcast and
<add> # the arguments passed in are arrays.
<add> res = np.pmt([[0.0, 0.8],[0.3, 0.8]],[12, 3],[2000, 20000])
<add> tgt = np.array([[-166.66667, -19311.258],[-626.90814, -19311.258]])
<add> assert_allclose(res, tgt)
<ide>
<ide> def test_ppmt(self):
<ide> np.round(np.ppmt(0.1/12, 1, 60, 55000), 2) == 710.25 | 1 |
Text | Text | change port number through example context | b0a65f93a5ab2de540825fab43b4d2ec01f22f36 | <ide><path>docs/userguide/dockerlinks.md
<ide> The components in this prefix are:
<ide> Docker uses this prefix format to define three distinct environment variables:
<ide>
<ide> * The `prefix_ADDR` variable contains the IP Address from the URL, for
<del>example `WEBDB_PORT_8080_TCP_ADDR=172.17.0.82`.
<add>example `WEBDB_PORT_5432_TCP_ADDR=172.17.0.82`.
<ide> * The `prefix_PORT` variable contains just the port number from the URL for
<del>example `WEBDB_PORT_8080_TCP_PORT=8080`.
<add>example `WEBDB_PORT_5432_TCP_PORT=5432`.
<ide> * The `prefix_PROTO` variable contains just the protocol from the URL for
<del>example `WEBDB_PORT_8080_TCP_PROTO=tcp`.
<add>example `WEBDB_PORT_5432_TCP_PROTO=tcp`.
<ide>
<ide> If the container exposes multiple ports, an environment variable set is
<ide> defined for each one. This means, for example, if a container exposes 4 ports
<ide> that Docker creates 12 environment variables, 3 for each port.
<ide> Additionally, Docker creates an environment variable called `<alias>_PORT`.
<ide> This variable contains the URL of the source container's first exposed port.
<ide> The 'first' port is defined as the exposed port with the lowest number.
<del>For example, consider the `WEBDB_PORT=tcp://172.17.0.82:8080` variable. If
<add>For example, consider the `WEBDB_PORT=tcp://172.17.0.82:5432` variable. If
<ide> that port is used for both tcp and udp, then the tcp one is specified.
<ide>
<ide> Finally, Docker also exposes each Docker originated environment variable | 1 |
Javascript | Javascript | restore context after an error happens | 9cd52b27fe7be3c320d1e94a016fc416e66569b1 | <ide><path>packages/react-dom/src/__tests__/ReactDOMFizzServer-test.js
<ide> describe('ReactDOMFizzServer', () => {
<ide> );
<ide> });
<ide>
<add> // @gate experimental
<add> it('should recover the outer context when an error happens inside a provider', async () => {
<add> const ContextA = React.createContext('A0');
<add> const ContextB = React.createContext('B0');
<add>
<add> function PrintA() {
<add> return (
<add> <ContextA.Consumer>{value => <Text text={value} />}</ContextA.Consumer>
<add> );
<add> }
<add>
<add> class PrintB extends React.Component {
<add> static contextType = ContextB;
<add> render() {
<add> return <Text text={this.context} />;
<add> }
<add> }
<add>
<add> function Throws() {
<add> const value = React.useContext(ContextA);
<add> throw new Error(value);
<add> }
<add>
<add> const loggedErrors = [];
<add> await act(async () => {
<add> const {startWriting} = ReactDOMFizzServer.pipeToNodeWritable(
<add> <div>
<add> <PrintA />
<add> <div>
<add> <ContextA.Provider value="A0.1">
<add> <Suspense
<add> fallback={
<add> <b>
<add> <Text text="Loading..." />
<add> </b>
<add> }>
<add> <ContextA.Provider value="A0.1.1">
<add> <Throws />
<add> </ContextA.Provider>
<add> </Suspense>
<add> <PrintB />
<add> </ContextA.Provider>
<add> </div>
<add> <PrintA />
<add> </div>,
<add> writable,
<add> {
<add> onError(x) {
<add> loggedErrors.push(x);
<add> },
<add> },
<add> );
<add> startWriting();
<add> });
<add> expect(loggedErrors.length).toBe(1);
<add> expect(loggedErrors[0].message).toEqual('A0.1.1');
<add> expect(getVisibleChildren(container)).toEqual(
<add> <div>
<add> A0
<add> <div>
<add> <b>Loading...</b>B0
<add> </div>
<add> A0
<add> </div>,
<add> );
<add> });
<add>
<ide> // @gate experimental
<ide> it('client renders a boundary if it errors before finishing the fallback', async () => {
<ide> function App({isClient}) {
<ide><path>packages/react-server/src/ReactFizzServer.js
<ide> function renderNode(request: Request, task: Task, node: ReactNodeList): void {
<ide> // Restore all active ReactContexts to what they were before.
<ide> switchContext(previousContext);
<ide> } else {
<add> // Restore the context. We assume that this will be restored by the inner
<add> // functions in case nothing throws so we don't use "finally" here.
<add> task.blockedSegment.formatContext = previousFormatContext;
<add> task.legacyContext = previousLegacyContext;
<add> task.context = previousContext;
<add> // Restore all active ReactContexts to what they were before.
<add> switchContext(previousContext);
<ide> // We assume that we don't need the correct context.
<ide> // Let's terminate the rest of the tree and don't render any siblings.
<ide> throw x; | 2 |
Javascript | Javascript | prevent extra method.tostring checks | dc3d707141a39bb4dedee3f8e86d6b7ad39f2591 | <ide><path>packages/ember-metal/lib/mixin.js
<ide> function giveMethodSuper(obj, key, method, values, descs) {
<ide>
<ide> if (hasSuper === undefined) {
<ide> hasSuper = method.toString().indexOf('_super');
<add> method.__hasSuper = hasSuper;
<ide> }
<ide>
<ide> if (hasSuper) { | 1 |
Ruby | Ruby | fix unittest test_arch_for_command for 10.5 | f150e5ece29d3e5c9bedfe557446a62380cd4f21 | <ide><path>Library/Homebrew/unittest.rb
<ide> def test_my_float_assumptions
<ide> end
<ide>
<ide> def test_arch_for_command
<del> # NOTE only works on Snow Leopard I bet, pick a better file!
<ide> arches=arch_for_command '/usr/bin/svn'
<del> assert_equal 3, arches.count
<del> assert arches.include?(:x86_64)
<add> if `sw_vers -productVersion` =~ /10\.(\d)\.(\d+)/ and $1.to_i >= 6
<add> assert_equal 3, arches.count
<add> assert arches.include?(:x86_64)
<add> else
<add> assert_equal 2, arches.count
<add> end
<ide> assert arches.include?(:i386)
<ide> assert arches.include?(:ppc7400)
<ide> end | 1 |
Python | Python | add a test script for model_utils | 896880f84dcf6615fe33123dd1e6fe24bc1a7896 | <ide><path>tests/manual/check_model_utils.py
<add>from __future__ import absolute_import
<add>from __future__ import print_function
<add>from keras.models import Sequential, Graph
<add>from keras.layers.core import Layer, Activation, Dense, Flatten, Reshape, Merge
<add>from keras.layers.convolutional import Convolution2D, MaxPooling2D
<add>import keras.utils.model_utils as model_utils
<add>
<add>print('-- Sequential model')
<add>left = Sequential()
<add>left.add(Convolution2D(32, 1, 3, 3, border_mode='valid'))
<add>left.add(MaxPooling2D(poolsize=(2, 2)))
<add>left.add(Flatten())
<add>left.add(Dense(32 * 13 * 13, 50))
<add>left.add(Activation('relu'))
<add>
<add>right = Sequential()
<add>right.add(Dense(784, 30))
<add>right.add(Activation('relu'))
<add>
<add>model = Sequential()
<add>model.add(Merge([left, right], mode='concat'))
<add>
<add>model.add(Dense(80, 10))
<add>model.add(Activation('softmax'))
<add>
<add>model_utils.print_model_layer_shapes(model, [(1, 1, 28, 28), (1, 784)])
<add>
<add>print('-- Graph model')
<add>graph = Graph()
<add>graph.add_input(name='input1', ndim=2)
<add>graph.add_input(name='input2', ndim=4)
<add>graph.add_node(Dense(32, 16), name='dense1', input='input1')
<add>graph.add_node(Dense(16, 4), name='dense3', input='dense1')
<add>
<add>graph.add_node(Convolution2D(32, 1, 3, 3), name='conv1', input='input2')
<add>graph.add_node(Flatten(), name='flatten1', input='conv1')
<add>graph.add_node(Dense(32 * 13 * 13, 10), name='dense4', input='flatten1')
<add>
<add>graph.add_output(name='output1', inputs=['dense1', 'dense3'], merge_mode='sum')
<add>graph.add_output(name='output2', inputs=['dense1', 'dense4'], merge_mode='concat')
<add>
<add>model_utils.print_graph_layer_shapes(graph,
<add> {'input1':(1, 32), 'input2':(1, 1, 28, 28)})
<add>
<add>print('Test script complete') | 1 |
Javascript | Javascript | fix user redirect on email account creation | 2a48f4231327aec380f724355ce2f08470d4650e | <ide><path>server/boot/a-extendUser.js
<ide> module.exports = function(app) {
<ide> });
<ide>
<ide> // send welcome email to new camper
<del> User.afterRemote('create', function(ctx, user, next) {
<add> User.afterRemote('create', function({ req, res }, user, next) {
<ide> debug('user created, sending email');
<ide> if (!user.email) { return next(); }
<add> const redirect = req.session && req.session.returnTo ?
<add> req.session.returnTo :
<add> '/';
<ide>
<ide> var mailOptions = {
<ide> type: 'email',
<ide> module.exports = function(app) {
<ide> debug('sending welcome email');
<ide> Email.send(mailOptions, function(err) {
<ide> if (err) { return next(err); }
<del> ctx.req.logIn(user, function(err) {
<add> req.logIn(user, function(err) {
<ide> if (err) { return next(err); }
<ide>
<del> ctx.req.flash('success', {
<add> req.flash('success', {
<ide> msg: [ "Welcome to Free Code Camp! We've created your account." ]
<ide> });
<del> ctx.res.redirect('/');
<add> res.redirect(redirect);
<ide> });
<ide> });
<ide> }); | 1 |
Javascript | Javascript | remove addparsedvariabletomodule helper | 5553166603c9f813bc99d4e77d102080bfcdb9ad | <ide><path>lib/JavascriptParserHelpers.js
<ide> const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
<ide> const UnsupportedFeatureWarning = require("./UnsupportedFeatureWarning");
<ide> const ConstDependency = require("./dependencies/ConstDependency");
<ide>
<del>exports.addParsedVariableToModule = (parser, name, expression) => {
<del> if (!parser.state.current.addVariable) return false;
<del> const deps = [];
<del> parser.parse(expression, {
<del> current: {
<del> addDependency: dep => {
<del> dep.userRequest = name;
<del> deps.push(dep);
<del> }
<del> },
<del> module: parser.state.module
<del> });
<del> parser.state.current.addVariable(name, expression, deps);
<del> return true;
<del>};
<del>
<ide> exports.getModulePath = (context, pathToModule) => {
<ide> let moduleJsPath = path.relative(context, pathToModule);
<ide> if (!/^[A-Z]:/i.test(moduleJsPath)) { | 1 |
Python | Python | fix ticket #928 | e02bf24487e84fb7bbb6bb2ffc25d5833f5ae30d | <ide><path>numpy/lib/function_base.py
<ide> def histogramdd(sample, bins=10, range=None, normed=False, weights=None):
<ide> Ncount[i][on_edge] -= 1
<ide>
<ide> # Flattened histogram matrix (1D)
<del> hist = zeros(nbin.prod(), float)
<add> # Reshape is used so that overlarge arrays
<add> # will raise an error.
<add> hist = zeros(nbin, float).reshape(-1)
<ide>
<ide> # Compute the sample indices in the flattened histogram matrix.
<ide> ni = nbin.argsort()
<ide><path>numpy/lib/tests/test_regression.py
<ide> def test_polydiv_type(self) :
<ide> q,r = np.polydiv(x,x)
<ide> assert_(q.dtype == np.float, msg)
<ide>
<add> def test_histogramdd_too_many_bins(self) :
<add> """Ticket 928."""
<add> assert_raises(ValueError, np.histogramdd, [np.ones(10)]*32)
<add>
<ide>
<ide> if __name__ == "__main__":
<ide> run_module_suite() | 2 |
Text | Text | add major features to the 6.1 release notes | 9bcf72fc1fa9648fb277a55bb3ba174d6393e9f8 | <ide><path>guides/source/6_1_release_notes.md
<ide> Ruby on Rails 6.1 Release Notes
<ide>
<ide> Highlights in Rails 6.1:
<ide>
<add>* Per-database Connection Switching
<add>* Horizontal Sharding
<add>* Strict Loading Associations
<add>* Delegated Types
<add>* Destroy Associations Async
<add>
<ide> These release notes cover only the major changes. To learn about various bug
<ide> fixes and changes, please refer to the change logs or check out the [list of
<ide> commits](https://github.com/rails/rails/commits/master) in the main Rails
<ide> guide.
<ide> Major Features
<ide> --------------
<ide>
<add>### Per-database Connection Switching
<add>
<add>Rails 6.1 provides you with the ability to [switch connections per-database](https://github.com/rails/rails/pull/40370). In 6.0 if you switched to the `reading` role then all database connections also switched to the reading role. Now in 6.1 if you set `legacy_connection_handling` to `false` in your configuration, Rails will allow you to switch connections for a single database by calling `connected_to` on the corresponding abstract class.
<add>
<add>### Horizontal Sharding
<add>
<add>Rails 6.0 provided the ability to functionally partition (multiple partitions, different schemas) your database but wasn't able to support horizontal sharding (same schema, multiple partitions). Rails wasn't able to support horizonal sharding because models in Active Record could only have one connection per-role per-class. This is now fixed and [horizontal sharding](https://github.com/rails/rails/pull/38531) with Rails is available.
<add>
<add>### Strict Loading Associations
<add>
<add>[Strict loading associations](https://github.com/rails/rails/pull/37400) allows you to ensure that all
<add>your associations are loaded eagerly and stop N+1's before they happen.
<add>
<add>### Delegated Types
<add>
<add>[Delegated Types](https://github.com/rails/rails/pull/39341) is an alternative to single-table inheritance. This is helpful for representing class hierarchies allowing the superclass to be a concrete class that is represented by its own table. Each subclass has its own table for additional attributes.
<add>
<add>### Destroy Associations Async
<add>
<add>[Destroy associations async](https://github.com/rails/rails/pull/40157) adds the ability for applications to `destroy` associations in a background job. This can help you avoid timeouts and other performance issues in your application when destroying data.
<add>
<ide> Railties
<ide> --------
<ide>
<ide> Please refer to the [Changelog][active-model] for detailed changes.
<ide>
<ide> ### Notable changes
<ide>
<add>* Active Model's errors are now objects with an interface that allows your application to more
<add> easily handle and interact with errors thrown by models.
<add> [The feature](https://github.com/rails/rails/pull/32313) includes a query interface, enables
<add> more precise testing, and access to error details.
<add>
<ide> Active Support
<ide> --------------
<ide> | 1 |
PHP | PHP | add copy button | 832d9a3e5a002d1b14d7fc5c15e37962a23b7783 | <ide><path>templates/layout/dev_error.php
<ide> padding: 10px;
<ide> }
<ide> .header-title {
<add> display: flex;
<add> align-items: center;
<ide> font-size: 30px;
<ide> margin: 0;
<ide> }
<del> .header-title:hover:after {
<del> content: attr(data-content);
<add> .header-title small {
<ide> font-size: 18px;
<del> vertical-align: middle;
<ide> cursor: pointer;
<add> margin-left: 10px;
<add> user-select: none;
<ide> }
<ide> .header-type {
<ide> display: block;
<ide> </head>
<ide> <body>
<ide> <header>
<del> <h1 class="header-title" data-content="📋">
<add> <h1 class="header-title">
<ide> <?= Debugger::formatHtmlMessage($this->fetch('title')) ?>
<add> <small>📋</small>
<ide> </h1>
<ide> <span class="header-type"><?= get_class($error) ?></span>
<ide> </header>
<ide> function each(els, cb) {
<ide> event.preventDefault();
<ide> });
<ide>
<del> bindEvent('.header-title', 'click', function(event) {
<add> bindEvent('.header-title small', 'click', function(event) {
<ide> event.preventDefault();
<ide> var text = '';
<del> each(this.childNodes, function(el) {
<del> text += el.textContent.trim();
<add> each(this.parentNode.childNodes, function(el) {
<add> if (el.nodeName !== 'SMALL') {
<add> text += el.textContent.trim();
<add> }
<ide> });
<ide>
<ide> // Use execCommand(copy) as it has the widest support.
<ide> function each(els, cb) {
<ide> document.execCommand('copy');
<ide>
<ide> // Show a success icon and then revert
<del> var original = el.getAttribute('data-content');
<del> el.setAttribute('data-content', '\ud83c\udf70');
<add> var original = el.innerText;
<add> el.innerText = '\ud83c\udf70';
<ide> setTimeout(function () {
<del> el.setAttribute('data-content', original);
<add> el.textContent = original;
<ide> }, 1000);
<ide> } catch (err) {
<ide> alert('Unable to update clipboard ' + err);
<ide> }
<ide> document.body.removeChild(textArea);
<del> this.parentNode.scrollIntoView(true);
<add> this.parentNode.parentNode.scrollIntoView(true);
<ide> });
<ide> });
<ide> </script> | 1 |
Text | Text | fix quickstart tutorial | e2b39088345e564a06ce332b740215600c29e481 | <ide><path>docs/tutorial/quickstart.md
<ide> Create a new Django project named `tutorial`, then start a new app called `quick
<ide> pip install djangorestframework
<ide>
<ide> # Set up a new project with a single application
<del> django-admin.py startproject tutorial
<add> django-admin.py startproject tutorial .
<ide> cd tutorial
<ide> django-admin.py startapp quickstart
<del> cd ..
<ide>
<ide> Now sync your database for the first time:
<ide> | 1 |
Ruby | Ruby | move some uninstall tests to new file | 4127a7b62422ed0b9c38dbe022ee958640b7c614 | <ide><path>Library/Homebrew/test/cmd/uninstall_spec.rb
<ide> .and be_a_success
<ide> end
<ide> end
<del>
<del>describe Homebrew do
<del> let(:dependency) { formula("dependency") { url "f-1" } }
<del> let(:dependent) do
<del> formula("dependent") do
<del> url "f-1"
<del> depends_on "dependency"
<del> end
<del> end
<del>
<del> let(:kegs_by_rack) { { dependency.rack => [Keg.new(dependency.latest_installed_prefix)] } }
<del>
<del> before do
<del> [dependency, dependent].each do |f|
<del> f.latest_installed_prefix.mkpath
<del> Keg.new(f.latest_installed_prefix).optlink
<del> end
<del>
<del> tab = Tab.empty
<del> tab.homebrew_version = "1.1.6"
<del> tab.tabfile = dependent.latest_installed_prefix/Tab::FILENAME
<del> tab.runtime_dependencies = [
<del> { "full_name" => "dependency", "version" => "1" },
<del> ]
<del> tab.write
<del>
<del> stub_formula_loader dependency
<del> stub_formula_loader dependent
<del> end
<del>
<del> describe "::handle_unsatisfied_dependents" do
<del> specify "when developer" do
<del> ENV["HOMEBREW_DEVELOPER"] = "1"
<del>
<del> expect {
<del> described_class.handle_unsatisfied_dependents(kegs_by_rack)
<del> }.to output(/Warning/).to_stderr
<del>
<del> expect(described_class).not_to have_failed
<del> end
<del>
<del> specify "when not developer" do
<del> expect {
<del> described_class.handle_unsatisfied_dependents(kegs_by_rack)
<del> }.to output(/Error/).to_stderr
<del>
<del> expect(described_class).to have_failed
<del> end
<del>
<del> specify "when not developer and `ignore_dependencies` is true" do
<del> expect {
<del> described_class.handle_unsatisfied_dependents(kegs_by_rack, ignore_dependencies: true)
<del> }.not_to output.to_stderr
<del>
<del> expect(described_class).not_to have_failed
<del> end
<del> end
<del>end
<ide><path>Library/Homebrew/test/uninstall_spec.rb
<add># typed: false
<add># frozen_string_literal: true
<add>
<add>require "uninstall"
<add>
<add>describe Homebrew::Uninstall do
<add> let(:dependency) { formula("dependency") { url "f-1" } }
<add> let(:dependent) do
<add> formula("dependent") do
<add> url "f-1"
<add> depends_on "dependency"
<add> end
<add> end
<add>
<add> let(:kegs_by_rack) { { dependency.rack => [Keg.new(dependency.latest_installed_prefix)] } }
<add>
<add> before do
<add> [dependency, dependent].each do |f|
<add> f.latest_installed_prefix.mkpath
<add> Keg.new(f.latest_installed_prefix).optlink
<add> end
<add>
<add> tab = Tab.empty
<add> tab.homebrew_version = "1.1.6"
<add> tab.tabfile = dependent.latest_installed_prefix/Tab::FILENAME
<add> tab.runtime_dependencies = [
<add> { "full_name" => "dependency", "version" => "1" },
<add> ]
<add> tab.write
<add>
<add> stub_formula_loader dependency
<add> stub_formula_loader dependent
<add> end
<add>
<add> describe "::handle_unsatisfied_dependents" do
<add> specify "when developer" do
<add> ENV["HOMEBREW_DEVELOPER"] = "1"
<add>
<add> expect {
<add> described_class.handle_unsatisfied_dependents(kegs_by_rack)
<add> }.to output(/Warning/).to_stderr
<add>
<add> expect(Homebrew).not_to have_failed
<add> end
<add>
<add> specify "when not developer" do
<add> expect {
<add> described_class.handle_unsatisfied_dependents(kegs_by_rack)
<add> }.to output(/Error/).to_stderr
<add>
<add> expect(Homebrew).to have_failed
<add> end
<add>
<add> specify "when not developer and `ignore_dependencies` is true" do
<add> expect {
<add> described_class.handle_unsatisfied_dependents(kegs_by_rack, ignore_dependencies: true)
<add> }.not_to output.to_stderr
<add>
<add> expect(Homebrew).not_to have_failed
<add> end
<add> end
<add>end | 2 |
Python | Python | fix bert example code for nsp and multiple choice | e2230ba77bbf68d9966458bbd0c66e15844ba456 | <ide><path>src/transformers/modeling_bert.py
<ide> def forward(
<ide> tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
<ide> model = BertForNextSentencePrediction.from_pretrained('bert-base-uncased')
<ide>
<del> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(0) # Batch size 1
<del> outputs = model(input_ids)
<del>
<del> seq_relationship_scores = outputs[0]
<add> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
<add> next_sentence = "The sky is blue due to the shorter wavelength of blue light."
<add> encoding = tokenizer.encode_plus(prompt, next_sentence, return_tensors='pt')
<ide>
<add> loss, logits = model(**encoding, next_sentence_label=torch.LongTensor([1]))
<add> assert logits[0, 0] < logits[0, 1] # next sentence was random
<ide> """
<ide>
<ide> outputs = self.bert(
<ide> def forward(
<ide> r"""
<ide> labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size,)`, `optional`, defaults to :obj:`None`):
<ide> Labels for computing the multiple choice classification loss.
<del> Indices should be in ``[0, ..., num_choices]`` where `num_choices` is the size of the second dimension
<add> Indices should be in ``[0, ..., num_choices-1]`` where `num_choices` is the size of the second dimension
<ide> of the input tensors. (see `input_ids` above)
<ide>
<ide> Returns:
<ide> def forward(
<ide>
<ide> tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
<ide> model = BertForMultipleChoice.from_pretrained('bert-base-uncased')
<del> choices = ["Hello, my dog is cute", "Hello, my cat is amazing"]
<ide>
<del> input_ids = torch.tensor([tokenizer.encode(s, add_special_tokens=True) for s in choices]).unsqueeze(0) # Batch size 1, 2 choices
<del> labels = torch.tensor(1).unsqueeze(0) # Batch size 1
<del> outputs = model(input_ids, labels=labels)
<add> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
<add> choice0 = "It is eaten with a fork and a knife."
<add> choice1 = "It is eaten while held in the hand."
<add> labels = torch.tensor(0) # choice0 is correct (according to Wikipedia ;))
<ide>
<del> loss, classification_scores = outputs[:2]
<add> encoding = tokenizer.batch_encode_plus([[prompt, choice0], [prompt, choice1]], return_tensors='pt', pad_to_max_length=True)
<add> outputs = model(**{k: v.unsqueeze(0) for k,v in encoding.items()}, labels=labels) # batch size is 1
<ide>
<add> # the linear classifier still needs to be trained
<add> loss, logits = outputs[:2]
<ide> """
<ide> num_choices = input_ids.shape[1]
<ide>
<ide><path>src/transformers/modeling_tf_bert.py
<ide> def call(self, inputs, **kwargs):
<ide>
<ide> tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
<ide> model = TFBertForNextSentencePrediction.from_pretrained('bert-base-uncased')
<del> input_ids = tf.constant(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True))[None, :] # Batch size 1
<del> outputs = model(input_ids)
<del> seq_relationship_scores = outputs[0]
<ide>
<add> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
<add> next_sentence = "The sky is blue due to the shorter wavelength of blue light."
<add> encoding = tokenizer.encode_plus(prompt, next_sentence, return_tensors='tf')
<add>
<add> logits = model(encoding['input_ids'], token_type_ids=encoding['token_type_ids'])[0]
<add> assert logits[0][0] < logits[0][1] # the next sentence was random
<ide> """
<ide> outputs = self.bert(inputs, **kwargs)
<ide>
<ide> def call(
<ide>
<ide> tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
<ide> model = TFBertForMultipleChoice.from_pretrained('bert-base-uncased')
<del> choices = ["Hello, my dog is cute", "Hello, my cat is amazing"]
<del> input_ids = tf.constant([tokenizer.encode(s) for s in choices])[None, :] # Batch size 1, 2 choices
<del> outputs = model(input_ids)
<del> classification_scores = outputs[0]
<ide>
<add> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
<add> choice0 = "It is eaten with a fork and a knife."
<add> choice1 = "It is eaten while held in the hand."
<add> encoding = tokenizer.batch_encode_plus([[prompt, choice0], [prompt, choice1]], return_tensors='tf', pad_to_max_length=True)
<add>
<add> # linear classifier on the output is not yet trained
<add> outputs = model(encoding['input_ids'][None, :])
<add> logits = outputs[0]
<ide> """
<ide> if isinstance(inputs, (tuple, list)):
<ide> input_ids = inputs[0] | 2 |
Python | Python | fix the .t attribute in the array_api namespace | eb865fa4683bca9a9d7c840f8addd30e39b62f5b | <ide><path>numpy/array_api/_array_object.py
<ide> def T(self) -> Array:
<ide> # https://data-apis.org/array-api/latest/API_specification/array_object.html#t
<ide> if self.ndim != 2:
<ide> raise ValueError("x.T requires x to have 2 dimensions. Use x.mT to transpose stacks of matrices and permute_dims() to permute dimensions.")
<del> return self._array.T
<add> return self.__class__._new(self._array.T) | 1 |
Text | Text | provide more guidance about process.version | 09e23b842b83ab0f2b093ea8d47821fabb47ede2 | <ide><path>doc/api/process.md
<ide> added: v0.1.3
<ide>
<ide> * {string}
<ide>
<del>The `process.version` property returns the Node.js version string in the form of
<del>`v<major>.<minor>.<patch>`.
<add>The `process.version` property contains the Node.js version string.
<ide>
<ide> ```js
<ide> console.log(`Version: ${process.version}`);
<add>// Version: v14.8.0
<ide> ```
<ide>
<add>To get the version string without the prepended _v_, use
<add>`process.versions.node`.
<add>
<ide> ## `process.versions`
<ide> <!-- YAML
<ide> added: v0.2.0 | 1 |
PHP | PHP | selectmonth | ebaf26c71b44f1f7650ba79d55cae0a64f029e7f | <ide><path>src/Illuminate/Html/FormBuilder.php
<ide> public function selectYear()
<ide> * @param string $name
<ide> * @param string $selected
<ide> * @param array $options
<add> * @param string $format
<ide> * @return string
<ide> */
<del> public function selectMonth($name, $selected = null, $options = array())
<add> public function selectMonth($name, $selected = null, $options = array(), $format = '%B')
<ide> {
<ide> $months = array();
<ide>
<ide> foreach (range(1, 12) as $month)
<ide> {
<del> $months[$month] = strftime('%B', mktime(0, 0, 0, $month, 1));
<add> $months[$month] = strftime($format, mktime(0, 0, 0, $month, 1));
<ide> }
<ide>
<ide> return $this->select($name, $months, $selected, $options); | 1 |
Python | Python | fix lint violations in the container api | 982665b586b826c644782905f036bf204acbb997 | <ide><path>libcloud/container/drivers/docker.py
<ide> def list_containers(self, image=None, all=True):
<ide> result = self.connection.request(
<ide> "/containers/json%s" % (ex)).object
<ide> except Exception as exc:
<del> if hasattr(exc, 'errno') and exc.errno == 111:
<add> errno = getattr(exc, 'errno', None)
<add> if errno == 111:
<ide> raise DockerException(
<del> exc.errno,
<add> errno,
<ide> 'Make sure docker host is accessible'
<ide> 'and the API port is correct')
<ide> raise
<ide> def deploy_container(self, name, image, parameters=None, start=True,
<ide> result = self.connection.request('/containers/create', data=data,
<ide> params=params, method='POST')
<ide> except Exception as e:
<del> if e.message.startswith('No such image:'):
<add> message = e.message or str(e)
<add> if message.startswith('No such image:'):
<ide> raise DockerException(None, 'No such image: %s' % image.name)
<ide> else:
<ide> raise DockerException(None, e)
<ide> def _get_api_version(self):
<ide> Get the docker API version information
<ide> """
<ide> result = self.connection.request('/version').object
<add> result = result or {}
<ide> api_version = result.get('ApiVersion')
<ide>
<ide> return api_version
<ide><path>libcloud/container/drivers/kubernetes.py
<ide> def list_containers(self, image=None, all=True):
<ide> result = self.connection.request(
<ide> ROOT_URL + "v1/pods").object
<ide> except Exception as exc:
<del> if hasattr(exc, 'errno') and exc.errno == 111:
<add> errno = getattr(exc, 'errno', None)
<add> if errno == 111:
<ide> raise KubernetesException(
<del> exc.errno,
<add> errno,
<ide> 'Make sure kube host is accessible'
<ide> 'and the API port is correct')
<ide> raise
<ide> def get_container(self, id):
<ide>
<ide> :rtype: :class:`libcloud.container.base.Container`
<ide> """
<del> result = self.connection.request(ROOT_URL + "v1/nodes/%s" %
<del> id).object
<add> # result = self.connection.request(ROOT_URL + "v1/nodes/%s" %
<add> # id).object
<ide>
<del> return self._to_container(result)
<add> # TODO: Fixme
<add> # return self._to_container(result)
<add> return None
<ide>
<ide> def list_clusters(self):
<ide> """
<ide> def list_clusters(self):
<ide> result = self.connection.request(
<ide> ROOT_URL + "v1/namespaces/").object
<ide> except Exception as exc:
<del> if hasattr(exc, 'errno') and exc.errno == 111:
<add> errno = getattr(exc, 'errno', None)
<add> if errno == 111:
<ide> raise KubernetesException(
<del> exc.errno,
<add> errno,
<ide> 'Make sure kube host is accessible'
<ide> 'and the API port is correct')
<ide> raise
<ide> def destroy_container(self, container):
<ide>
<ide> :rtype: ``bool``
<ide> """
<del> return self.ex_delete_pod(container.extra['namespace'],
<del> container.extra['pod'])
<add> return self.ex_destroy_pod(container.extra['namespace'],
<add> container.extra['pod'])
<ide>
<ide> def ex_list_pods(self):
<ide> """
<ide> def _get_api_version(self):
<ide> Get the docker API version information
<ide> """
<ide> result = self.connection.request('/version').object
<add> result = result or {}
<ide> api_version = result.get('ApiVersion')
<ide>
<ide> return api_version | 2 |
PHP | PHP | add test for | 4d8a51f035becb5e289aaa5c4b2bec9b2867a4de | <ide><path>tests/TestCase/I18n/I18nTest.php
<ide> public function testBasicDomainFunction()
<ide> $package = new Package('default');
<ide> $package->setMessages([
<ide> 'Cow' => 'Le moo',
<del> 'The {0} is tasty' => 'The {0} is delicious'
<add> 'The {0} is tasty' => 'The {0} is delicious',
<add> 'Average price {0}' => 'Price Average {0}',
<ide> ]);
<ide> return $package;
<ide> });
<add> $this->assertEquals('Le moo', __d('custom', 'Cow'));
<add>
<ide> $result = __d('custom', 'The {0} is tasty', ['fruit']);
<ide> $this->assertEquals('The fruit is delicious', $result);
<add>
<add> $result = __d('custom', 'Average price {0}', ['9.99']);
<add> $this->assertEquals('Price Average 9.99', $result);
<ide> }
<ide>
<ide> /** | 1 |
Go | Go | add breakout tests | 221617dbcd9431f14a3779d8bac9aba52f78ea21 | <ide><path>pkg/archive/archive.go
<ide> type (
<ide> Archiver struct {
<ide> Untar func(io.Reader, string, *TarOptions) error
<ide> }
<add>
<add> // breakoutError is used to differentiate errors related to breaking out
<add> // When testing archive breakout in the unit tests, this error is expected
<add> // in order for the test to pass.
<add> breakoutError error
<ide> )
<ide>
<ide> var (
<ide><path>pkg/archive/archive_test.go
<ide> import (
<ide> "os"
<ide> "os/exec"
<ide> "path"
<add> "path/filepath"
<ide> "syscall"
<ide> "testing"
<ide> "time"
<ide> func TestTarWithOptions(t *testing.T) {
<ide> // Failing prevents the archives from being uncompressed during ADD
<ide> func TestTypeXGlobalHeaderDoesNotFail(t *testing.T) {
<ide> hdr := tar.Header{Typeflag: tar.TypeXGlobalHeader}
<del> err := createTarFile("pax_global_header", "some_dir", &hdr, nil, true)
<add> tmpDir, err := ioutil.TempDir("", "docker-test-archive-pax-test")
<add> if err != nil {
<add> t.Fatal(err)
<add> }
<add> defer os.RemoveAll(tmpDir)
<add> err = createTarFile(filepath.Join(tmpDir, "pax_global_header"), tmpDir, &hdr, nil, true)
<ide> if err != nil {
<ide> t.Fatal(err)
<ide> }
<ide> func BenchmarkTarUntarWithLinks(b *testing.B) {
<ide> os.RemoveAll(target)
<ide> }
<ide> }
<add>
<add>func TestUntarInvalidFilenames(t *testing.T) {
<add> for i, headers := range [][]*tar.Header{
<add> {
<add> {
<add> Name: "../victim/dotdot",
<add> Typeflag: tar.TypeReg,
<add> Mode: 0644,
<add> },
<add> },
<add> {
<add> {
<add> // Note the leading slash
<add> Name: "/../victim/slash-dotdot",
<add> Typeflag: tar.TypeReg,
<add> Mode: 0644,
<add> },
<add> },
<add> } {
<add> if err := testBreakout("untar", "docker-TestUntarInvalidFilenames", headers); err != nil {
<add> t.Fatalf("i=%d. %v", i, err)
<add> }
<add> }
<add>}
<add>
<add>func TestUntarInvalidHardlink(t *testing.T) {
<add> for i, headers := range [][]*tar.Header{
<add> { // try reading victim/hello (../)
<add> {
<add> Name: "dotdot",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "../victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // try reading victim/hello (/../)
<add> {
<add> Name: "slash-dotdot",
<add> Typeflag: tar.TypeLink,
<add> // Note the leading slash
<add> Linkname: "/../victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // try writing victim/file
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "loophole-victim/file",
<add> Typeflag: tar.TypeReg,
<add> Mode: 0644,
<add> },
<add> },
<add> { // try reading victim/hello (hardlink, symlink)
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "symlink",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "loophole-victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // Try reading victim/hello (hardlink, hardlink)
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "hardlink",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "loophole-victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // Try removing victim directory (hardlink)
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeReg,
<add> Mode: 0644,
<add> },
<add> },
<add> } {
<add> if err := testBreakout("untar", "docker-TestUntarInvalidHardlink", headers); err != nil {
<add> t.Fatalf("i=%d. %v", i, err)
<add> }
<add> }
<add>}
<add>
<add>func TestUntarInvalidSymlink(t *testing.T) {
<add> for i, headers := range [][]*tar.Header{
<add> { // try reading victim/hello (../)
<add> {
<add> Name: "dotdot",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "../victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // try reading victim/hello (/../)
<add> {
<add> Name: "slash-dotdot",
<add> Typeflag: tar.TypeSymlink,
<add> // Note the leading slash
<add> Linkname: "/../victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // try writing victim/file
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "loophole-victim/file",
<add> Typeflag: tar.TypeReg,
<add> Mode: 0644,
<add> },
<add> },
<add> { // try reading victim/hello (symlink, symlink)
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "symlink",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "loophole-victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // try reading victim/hello (symlink, hardlink)
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "hardlink",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "loophole-victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // try removing victim directory (symlink)
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeReg,
<add> Mode: 0644,
<add> },
<add> },
<add> } {
<add> if err := testBreakout("untar", "docker-TestUntarInvalidSymlink", headers); err != nil {
<add> t.Fatalf("i=%d. %v", i, err)
<add> }
<add> }
<add>}
<ide><path>pkg/archive/diff_test.go
<add>package archive
<add>
<add>import (
<add> "testing"
<add>
<add> "github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"
<add>)
<add>
<add>func TestApplyLayerInvalidFilenames(t *testing.T) {
<add> for i, headers := range [][]*tar.Header{
<add> {
<add> {
<add> Name: "../victim/dotdot",
<add> Typeflag: tar.TypeReg,
<add> Mode: 0644,
<add> },
<add> },
<add> {
<add> {
<add> // Note the leading slash
<add> Name: "/../victim/slash-dotdot",
<add> Typeflag: tar.TypeReg,
<add> Mode: 0644,
<add> },
<add> },
<add> } {
<add> if err := testBreakout("applylayer", "docker-TestApplyLayerInvalidFilenames", headers); err != nil {
<add> t.Fatalf("i=%d. %v", i, err)
<add> }
<add> }
<add>}
<add>
<add>func TestApplyLayerInvalidHardlink(t *testing.T) {
<add> for i, headers := range [][]*tar.Header{
<add> { // try reading victim/hello (../)
<add> {
<add> Name: "dotdot",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "../victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // try reading victim/hello (/../)
<add> {
<add> Name: "slash-dotdot",
<add> Typeflag: tar.TypeLink,
<add> // Note the leading slash
<add> Linkname: "/../victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // try writing victim/file
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "loophole-victim/file",
<add> Typeflag: tar.TypeReg,
<add> Mode: 0644,
<add> },
<add> },
<add> { // try reading victim/hello (hardlink, symlink)
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "symlink",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "loophole-victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // Try reading victim/hello (hardlink, hardlink)
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "hardlink",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "loophole-victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // Try removing victim directory (hardlink)
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeReg,
<add> Mode: 0644,
<add> },
<add> },
<add> } {
<add> if err := testBreakout("applylayer", "docker-TestApplyLayerInvalidHardlink", headers); err != nil {
<add> t.Fatalf("i=%d. %v", i, err)
<add> }
<add> }
<add>}
<add>
<add>func TestApplyLayerInvalidSymlink(t *testing.T) {
<add> for i, headers := range [][]*tar.Header{
<add> { // try reading victim/hello (../)
<add> {
<add> Name: "dotdot",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "../victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // try reading victim/hello (/../)
<add> {
<add> Name: "slash-dotdot",
<add> Typeflag: tar.TypeSymlink,
<add> // Note the leading slash
<add> Linkname: "/../victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // try writing victim/file
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "loophole-victim/file",
<add> Typeflag: tar.TypeReg,
<add> Mode: 0644,
<add> },
<add> },
<add> { // try reading victim/hello (symlink, symlink)
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "symlink",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "loophole-victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // try reading victim/hello (symlink, hardlink)
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "hardlink",
<add> Typeflag: tar.TypeLink,
<add> Linkname: "loophole-victim/hello",
<add> Mode: 0644,
<add> },
<add> },
<add> { // try removing victim directory (symlink)
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeSymlink,
<add> Linkname: "../victim",
<add> Mode: 0755,
<add> },
<add> {
<add> Name: "loophole-victim",
<add> Typeflag: tar.TypeReg,
<add> Mode: 0644,
<add> },
<add> },
<add> } {
<add> if err := testBreakout("applylayer", "docker-TestApplyLayerInvalidSymlink", headers); err != nil {
<add> t.Fatalf("i=%d. %v", i, err)
<add> }
<add> }
<add>}
<ide><path>pkg/archive/utils_test.go
<add>package archive
<add>
<add>import (
<add> "bytes"
<add> "fmt"
<add> "io"
<add> "io/ioutil"
<add> "os"
<add> "path/filepath"
<add> "time"
<add>
<add> "github.com/docker/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"
<add>)
<add>
<add>var testUntarFns = map[string]func(string, io.Reader) error{
<add> "untar": func(dest string, r io.Reader) error {
<add> return Untar(r, dest, nil)
<add> },
<add> "applylayer": func(dest string, r io.Reader) error {
<add> return ApplyLayer(dest, ArchiveReader(r))
<add> },
<add>}
<add>
<add>// testBreakout is a helper function that, within the provided `tmpdir` directory,
<add>// creates a `victim` folder with a generated `hello` file in it.
<add>// `untar` extracts to a directory named `dest`, the tar file created from `headers`.
<add>//
<add>// Here are the tested scenarios:
<add>// - removed `victim` folder (write)
<add>// - removed files from `victim` folder (write)
<add>// - new files in `victim` folder (write)
<add>// - modified files in `victim` folder (write)
<add>// - file in `dest` with same content as `victim/hello` (read)
<add>//
<add>// When using testBreakout make sure you cover one of the scenarios listed above.
<add>func testBreakout(untarFn string, tmpdir string, headers []*tar.Header) error {
<add> tmpdir, err := ioutil.TempDir("", tmpdir)
<add> if err != nil {
<add> return err
<add> }
<add> defer os.RemoveAll(tmpdir)
<add>
<add> dest := filepath.Join(tmpdir, "dest")
<add> if err := os.Mkdir(dest, 0755); err != nil {
<add> return err
<add> }
<add>
<add> victim := filepath.Join(tmpdir, "victim")
<add> if err := os.Mkdir(victim, 0755); err != nil {
<add> return err
<add> }
<add> hello := filepath.Join(victim, "hello")
<add> helloData, err := time.Now().MarshalText()
<add> if err != nil {
<add> return err
<add> }
<add> if err := ioutil.WriteFile(hello, helloData, 0644); err != nil {
<add> return err
<add> }
<add> helloStat, err := os.Stat(hello)
<add> if err != nil {
<add> return err
<add> }
<add>
<add> reader, writer := io.Pipe()
<add> go func() {
<add> t := tar.NewWriter(writer)
<add> for _, hdr := range headers {
<add> t.WriteHeader(hdr)
<add> }
<add> t.Close()
<add> }()
<add>
<add> untar := testUntarFns[untarFn]
<add> if untar == nil {
<add> return fmt.Errorf("could not find untar function %q in testUntarFns", untarFn)
<add> }
<add> if err := untar(dest, reader); err != nil {
<add> if _, ok := err.(breakoutError); !ok {
<add> // If untar returns an error unrelated to an archive breakout,
<add> // then consider this an unexpected error and abort.
<add> return err
<add> }
<add> // Here, untar detected the breakout.
<add> // Let's move on verifying that indeed there was no breakout.
<add> fmt.Printf("breakoutError: %v\n", err)
<add> }
<add>
<add> // Check victim folder
<add> f, err := os.Open(victim)
<add> if err != nil {
<add> // codepath taken if victim folder was removed
<add> return fmt.Errorf("archive breakout: error reading %q: %v", victim, err)
<add> }
<add> defer f.Close()
<add>
<add> // Check contents of victim folder
<add> //
<add> // We are only interested in getting 2 files from the victim folder, because if all is well
<add> // we expect only one result, the `hello` file. If there is a second result, it cannot
<add> // hold the same name `hello` and we assume that a new file got created in the victim folder.
<add> // That is enough to detect an archive breakout.
<add> names, err := f.Readdirnames(2)
<add> if err != nil {
<add> // codepath taken if victim is not a folder
<add> return fmt.Errorf("archive breakout: error reading directory content of %q: %v", victim, err)
<add> }
<add> for _, name := range names {
<add> if name != "hello" {
<add> // codepath taken if new file was created in victim folder
<add> return fmt.Errorf("archive breakout: new file %q", name)
<add> }
<add> }
<add>
<add> // Check victim/hello
<add> f, err = os.Open(hello)
<add> if err != nil {
<add> // codepath taken if read permissions were removed
<add> return fmt.Errorf("archive breakout: could not lstat %q: %v", hello, err)
<add> }
<add> defer f.Close()
<add> b, err := ioutil.ReadAll(f)
<add> if err != nil {
<add> return err
<add> }
<add> fi, err := f.Stat()
<add> if err != nil {
<add> return err
<add> }
<add> if helloStat.IsDir() != fi.IsDir() ||
<add> // TODO: cannot check for fi.ModTime() change
<add> helloStat.Mode() != fi.Mode() ||
<add> helloStat.Size() != fi.Size() ||
<add> !bytes.Equal(helloData, b) {
<add> // codepath taken if hello has been modified
<add> return fmt.Errorf("archive breakout: file %q has been modified. Contents: expected=%q, got=%q. FileInfo: expected=%#v, got=%#v.", hello, helloData, b, helloStat, fi)
<add> }
<add>
<add> // Check that nothing in dest/ has the same content as victim/hello.
<add> // Since victim/hello was generated with time.Now(), it is safe to assume
<add> // that any file whose content matches exactly victim/hello, managed somehow
<add> // to access victim/hello.
<add> return filepath.Walk(dest, func(path string, info os.FileInfo, err error) error {
<add> if info.IsDir() {
<add> if err != nil {
<add> // skip directory if error
<add> return filepath.SkipDir
<add> }
<add> // enter directory
<add> return nil
<add> }
<add> if err != nil {
<add> // skip file if error
<add> return nil
<add> }
<add> b, err := ioutil.ReadFile(path)
<add> if err != nil {
<add> // Houston, we have a problem. Aborting (space)walk.
<add> return err
<add> }
<add> if bytes.Equal(helloData, b) {
<add> return fmt.Errorf("archive breakout: file %q has been accessed via %q", hello, path)
<add> }
<add> return nil
<add> })
<add>} | 4 |
Text | Text | update http urls to https in doc/api | 7ab784000aad7df44a27d1dc2ad5a10395fd57e7 | <ide><path>doc/api/_toc.md
<ide> <div class="line"></div>
<ide>
<ide> * [GitHub Repo & Issue Tracker](https://github.com/nodejs/node)
<del>* [Mailing List](http://groups.google.com/group/nodejs)
<add>* [Mailing List](https://groups.google.com/group/nodejs)
<ide><path>doc/api/crypto.md
<ide> the `crypto`, `tls`, and `https` modules and are generally specific to OpenSSL.
<ide> [`verify.verify()`]: #crypto_verify_verify_object_signature_signatureformat
<ide> [Caveats]: #crypto_support_for_weak_or_compromised_algorithms
<ide> [Crypto Constants]: #crypto_crypto_constants_1
<del>[HTML5's `keygen` element]: http://www.w3.org/TR/html5/forms.html#the-keygen-element
<add>[HTML5's `keygen` element]: https://www.w3.org/TR/html5/forms.html#the-keygen-element
<ide> [NIST SP 800-131A]: http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-131Ar1.pdf
<ide> [NIST SP 800-132]: http://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf
<ide> [Nonce-Disrespecting Adversaries]: https://github.com/nonce-disrespect/nonce-disrespect
<ide><path>doc/api/tls.md
<ide> A key is *required* for ciphers that make use of certificates. Either `key` or
<ide>
<ide> If the 'ca' option is not given, then Node.js will use the default
<ide> publicly trusted list of CAs as given in
<del><http://mxr.mozilla.org/mozilla/source/security/nss/lib/ckfw/builtins/certdata.txt>.
<add><https://hg.mozilla.org/mozilla-central/raw-file/tip/security/nss/lib/ckfw/builtins/certdata.txt>.
<ide>
<ide>
<ide> ## tls.createServer([options][, secureConnectionListener])
<ide><path>doc/api/zlib.md
<ide> http.createServer((request, response) => {
<ide> }
<ide>
<ide> // Note: This is not a conformant accept-encoding parser.
<del> // See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3
<add> // See https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.3
<ide> if (/\bdeflate\b/.test(acceptEncoding)) {
<ide> response.writeHead(200, { 'Content-Encoding': 'deflate' });
<ide> raw.pipe(zlib.createDeflate()).pipe(response);
<ide> All of the constants defined in `zlib.h` are also defined on
<ide> `require('zlib').constants`. In the normal course of operations, it will not be
<ide> necessary to use these constants. They are documented so that their presence is
<ide> not surprising. This section is taken almost directly from the
<del>[zlib documentation][]. See <http://zlib.net/manual.html#Constants> for more
<add>[zlib documentation][]. See <https://zlib.net/manual.html#Constants> for more
<ide> details.
<ide>
<ide> *Note*: Previously, the constants were available directly from
<ide> ignored by the decompression classes.
<ide> * `info` {boolean} (If `true`, returns an object with `buffer` and `engine`)
<ide>
<ide> See the description of `deflateInit2` and `inflateInit2` at
<del><http://zlib.net/manual.html#Advanced> for more information on these.
<add><https://zlib.net/manual.html#Advanced> for more information on these.
<ide>
<ide> ## Class: zlib.Deflate
<ide> <!-- YAML
<ide> Decompress a chunk of data with [Unzip][].
<ide> [Unzip]: #zlib_class_zlib_unzip
<ide> [`UV_THREADPOOL_SIZE`]: cli.html#cli_uv_threadpool_size_size
<ide> [options]: #zlib_class_options
<del>[zlib documentation]: http://zlib.net/manual.html#Constants
<add>[zlib documentation]: https://zlib.net/manual.html#Constants | 4 |
Ruby | Ruby | reduce object allocations in journey | 2db4c0203adc97d69a64fefc95f3fd62e642a05f | <ide><path>actionpack/lib/action_dispatch/journey/gtg/transition_table.rb
<ide> def move(t, a)
<ide> return [] if t.empty?
<ide>
<ide> regexps = []
<add> strings = []
<ide>
<del> t.map { |s|
<add> t.each { |s|
<ide> if states = @regexp_states[s]
<del> regexps.concat states.map { |re, v| re.match?(a) ? v : nil }
<add> states.each { |re, v| regexps << v if re.match?(a) && !v.nil? }
<ide> end
<ide>
<ide> if states = @string_states[s]
<del> states[a]
<add> strings << states[a] unless states[a].nil?
<ide> end
<del> }.compact.concat regexps
<add> }
<add> strings.concat regexps
<ide> end
<ide>
<ide> def as_json(options = nil) | 1 |
Javascript | Javascript | add a test for expect & checkexpectation | 6eeb06f234ea5766831f2c51dbb2e3c84bc9bff6 | <ide><path>test/parallel/test-http2-compat-expect-handling.js
<add>// Flags: --expose-http2
<add>'use strict';
<add>
<add>const common = require('../common');
<add>if (!common.hasCrypto)
<add> common.skip('missing crypto');
<add>const assert = require('assert');
<add>const http2 = require('http2');
<add>
<add>const expectValue = 'meoww';
<add>
<add>const server = http2.createServer(common.mustNotCall());
<add>
<add>server.once('checkExpectation', common.mustCall((req, res) => {
<add> assert.strictEqual(req.headers['expect'], expectValue);
<add> res.statusCode = 417;
<add> res.end();
<add>}));
<add>
<add>server.listen(0, common.mustCall(() => nextTest(2)));
<add>
<add>function nextTest(testsToRun) {
<add> if (!testsToRun) {
<add> return server.close();
<add> }
<add>
<add> const port = server.address().port;
<add> const client = http2.connect(`http://localhost:${port}`);
<add> const req = client.request({
<add> ':path': '/',
<add> ':method': 'GET',
<add> ':scheme': 'http',
<add> ':authority': `localhost:${port}`,
<add> expect: expectValue
<add> });
<add>
<add> req.on('response', common.mustCall((headers) => {
<add> assert.strictEqual(headers[':status'], 417);
<add> req.resume();
<add> }));
<add>
<add> req.on('end', common.mustCall(() => {
<add> client.destroy();
<add> nextTest(testsToRun - 1);
<add> }));
<add>} | 1 |
Javascript | Javascript | fix a comment in testinit.js | 7bdf307b51e4d4a891b123a96d4899e31bfba024 | <ide><path>test/data/testinit.js
<ide> QUnit.basicTests = ( QUnit.urlParams.module + "" ) === "basic";
<ide> // Says whether jQuery positional selector extensions are supported.
<ide> // A full selector engine is required to support them as they need to be evaluated
<ide> // left-to-right. Remove that property when support for positional selectors is dropped.
<del>// if your custom jQuery versions relies more on native qSA.
<ide> QUnit.jQuerySelectorsPos = true;
<ide>
<ide> // Says whether jQuery selector extensions are supported. Change that to `false` | 1 |
Go | Go | keep processing signals after the first one | 88cb9f3116e41b00b00fdccf6359a555e87061bd | <ide><path>commands.go
<ide> func (cli *DockerCli) CmdRun(args ...string) error {
<ide> if err := cli.CmdStop("-t", "4", runResult.ID); err != nil {
<ide> fmt.Printf("failed to stop container:", err)
<ide> }
<del> return
<ide> }
<ide> }
<ide> }() | 1 |
Go | Go | change url of robots.txt test to dockerproject.com | 367e66e9721c33a64ab091bd5430ab4a9af12083 | <ide><path>integration-cli/docker_cli_build_test.go
<ide> RUN mkdir /exists
<ide> RUN touch /exists/exists_file
<ide> RUN chown -R dockerio.dockerio /exists
<ide> COPY test_file1 test_file2 /exists/
<del>ADD test_file3 test_file4 https://docker.com/robots.txt /exists/
<add>ADD test_file3 test_file4 https://dockerproject.com/robots.txt /exists/
<ide> RUN [ $(ls -l / | grep exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
<ide> RUN [ $(ls -l /exists/test_file1 | awk '{print $3":"$4}') = 'root:root' ]
<ide> RUN [ $(ls -l /exists/test_file2 | awk '{print $3":"$4}') = 'root:root' ] | 1 |
Javascript | Javascript | simplify vector#slice in eager world | 156953cb5741212b9b44c3e6d6c22cfaa4b523a1 | <ide><path>dist/immutable.js
<ide> function resolveEnd(end, size) {
<ide> return resolveIndex(end, size, size);
<ide> }
<ide> function resolveIndex(index, size, defaultIndex) {
<del> return index == null ? defaultIndex : index < 0 ? Math.max(0, size + index) : size == null ? index : Math.min(size, index);
<add> return index === undefined ? defaultIndex : index < 0 ? Math.max(0, size + index) : size == null ? index : Math.min(size, index);
<ide> }
<ide> function valueMapper(v) {
<ide> return v;
<ide> var $Vector = Vector;
<ide> return setVectorBounds(this, 0, size);
<ide> },
<ide> slice: function(begin, end) {
<del> var sliceSequence = $traceurRuntime.superCall(this, $Vector.prototype, "slice", [begin, end]);
<del> if (sliceSequence !== this) {
<del> var vector = this;
<del> var size = vector.size;
<del> sliceSequence.toVector = (function() {
<del> return setVectorBounds(vector, begin < 0 ? Math.max(0, size + begin) : size ? Math.min(size, begin) : begin, end == null ? size : end < 0 ? Math.max(0, size + end) : size ? Math.min(size, end) : end);
<del> });
<add> var size = this.size;
<add> if (wholeSlice(begin, end, size)) {
<add> return this;
<ide> }
<del> return sliceSequence;
<add> return setVectorBounds(this, resolveBegin(begin, size), resolveEnd(end, size));
<ide> },
<ide> __iterator: function(type, reverse) {
<ide> return new VectorIterator(this, type, reverse);
<ide><path>dist/immutable.min.js
<ide> * of patent rights can be found in the PATENTS file in the same directory.
<ide> */
<ide> function t(){function t(t,e,r,n){var i;if(n){var u=n.prototype;i=Ye.create(u)}else i=t.prototype;return Ye.keys(e).forEach(function(t){i[t]=e[t]}),n&&Ye.keys(n).forEach(function(e){t[e]=n[e]}),Ye.keys(r).forEach(function(e){t[e]=r[e]}),i.constructor=t,t.prototype=i,t}function e(t,e,r,n){return Ye.getPrototypeOf(e)[r].apply(t,n)}function r(t,r,n){e(t,r,"constructor",n)}function n(t,e){var r=t.prototype;return Object.keys(e).forEach(function(t){r[t]=e[t]}),t}function i(t,e){return t===e?0!==t||0!==e||1/t===1/e:t!==t?e!==e:t&&"function"==typeof t.equals?t.equals(e):!1}function u(t){return t.value=!1,t}function s(t){t&&(t.value=!0)}function a(){}function o(t,e){e=e||0;for(var r=Math.max(0,t.length-e),n=Array(r),i=0;r>i;i++)n[i]=t[i+e];return n}function h(t,e){if(!t)throw Error(e)}function c(t){if(!t)return 0;if(t===!0)return 1;var e=typeof t;if("number"===e){if((0|t)===t)return t&nr;t=""+t,e="string"}return"string"===e?t.length>sr?f(t):_(t):t.hashCode?c("function"==typeof t.hashCode?t.hashCode():t.hashCode):l(t)}function f(t){var e=hr[t];return null==e&&(e=_(t),or===ar&&(or=0,hr={}),or++,hr[t]=e),e}function _(t){for(var e=0,r=0;t.length>r;r++)e=31*e+t.charCodeAt(r)&nr;return e}function l(t){var e=rr&&rr.get(t);if(e)return e;if(e=t[ur])return e;if(!er){if(e=t.propertyIsEnumerable&&t.propertyIsEnumerable[ur])return e;if(e=v(t))return e}if(Object.isExtensible&&!Object.isExtensible(t))throw Error("Non-extensible objects are not allowed as keys.");if(e=++ir&nr,rr)rr.set(t,e);else if(er)Object.defineProperty(t,ur,{enumerable:!1,configurable:!1,writable:!1,value:e});else if(t.propertyIsEnumerable&&t.propertyIsEnumerable===t.constructor.prototype.propertyIsEnumerable)t.propertyIsEnumerable=function(){return this.constructor.prototype.propertyIsEnumerable.apply(this,arguments)},t.propertyIsEnumerable[ur]=e;else{if(!t.nodeType)throw Error("Unable to set a non-enumerable property on object.");t[ur]=e}return e}function v(t){if(t&&t.nodeType>0)switch(t.nodeType){case 1:return t.uniqueID;case 9:return t.documentElement&&t.documentElement.uniqueID
<del>}}function p(t,e,r,n){var i=0===t?e:1===t?r:[e,r];return n?n.value=i:n={value:i,done:!1},n}function m(){return{value:void 0,done:!0}}function y(t){return!!w(t)}function d(t){return t&&"function"==typeof t.next}function g(t){var e=w(t);return e&&e.call(t)}function w(t){var e=t&&(vr&&t[vr]||t[lr]);return"function"==typeof e?e:void 0}function S(t){return!(!t||!t[Br])}function z(t){return!(!t||!t[wr])}function q(t){return!(!t||!t[Sr])}function I(t){return!(!t||!t[zr])}function b(t){return q(t)||I(t)}function x(){return Zr||(Zr=new Qr([]))}function k(t){var e=z(t)?t:D(t,!1);return arguments.length>1&&(e=e.map(arguments[1],arguments.length>2?arguments[2]:void 0)),e}function M(t,e){return S(t)?e:t.constructor.from(e)}function D(t,e){var r=e&&"string"==typeof t?new Qr([t]):C(t)?new Qr(t):d(t)?new Fr(t):y(t)?new Gr(t):(e?O(t):"object"==typeof t)?new Hr(t):e?new Qr([t]):null;if(!r)throw new TypeError("Expected iterable: "+t);return r}function C(t){return t&&"number"==typeof t.length}function O(t){return t&&t.constructor===Object}function E(t,e,r){return(0===t||null!=r&&-r>=t)&&(null==e||null!=r&&e>=r)}function A(t,e){return R(t,e,0)}function j(t,e){return R(t,e,e)}function R(t,e,r){return null==t?r:0>t?Math.max(0,e+t):null==e?t:Math.min(e,t)}function U(t){return t}function K(t,e){return e}function P(t,e){return[e,t]}function W(){return!0}function B(t){return function(){return!t.apply(this,arguments)}}function L(t){return"string"==typeof t?JSON.stringify(t):t}function J(t,e){return t>e?1:e>t?-1:0}function T(t,e){return 0>e?(null==t.size&&t.cacheResult(),t.size+e):e}function V(t){return null==t.size&&t.cacheResult(),N(t.size),t.size}function N(t){h(1/0!==t,"Cannot perform this action with an infinite sequence.")}function Y(t,e,r,n){var i=t._cache;if(i){for(var u=i.length-1,s=0;u>=s;s++){var a=i[r?u-s:s];if(e(a[1],n?a[0]:s,t)===!1)return s+1}return s}return t.__iterateUncached(e,r)}function X(t,e,r,n){var i=t._cache;if(i){var u=i.length-1,s=0;return new mr(function(){var t=i[r?u-s:s];return s++>u?m():p(e,n?t[0]:s-1,t[1])})}return t.__iteratorUncached(e,r)
<add>}}function p(t,e,r,n){var i=0===t?e:1===t?r:[e,r];return n?n.value=i:n={value:i,done:!1},n}function m(){return{value:void 0,done:!0}}function y(t){return!!w(t)}function d(t){return t&&"function"==typeof t.next}function g(t){var e=w(t);return e&&e.call(t)}function w(t){var e=t&&(vr&&t[vr]||t[lr]);return"function"==typeof e?e:void 0}function S(t){return!(!t||!t[Br])}function z(t){return!(!t||!t[wr])}function q(t){return!(!t||!t[Sr])}function I(t){return!(!t||!t[zr])}function b(t){return q(t)||I(t)}function x(){return Zr||(Zr=new Qr([]))}function k(t){var e=z(t)?t:D(t,!1);return arguments.length>1&&(e=e.map(arguments[1],arguments.length>2?arguments[2]:void 0)),e}function M(t,e){return S(t)?e:t.constructor.from(e)}function D(t,e){var r=e&&"string"==typeof t?new Qr([t]):C(t)?new Qr(t):d(t)?new Fr(t):y(t)?new Gr(t):(e?O(t):"object"==typeof t)?new Hr(t):e?new Qr([t]):null;if(!r)throw new TypeError("Expected iterable: "+t);return r}function C(t){return t&&"number"==typeof t.length}function O(t){return t&&t.constructor===Object}function E(t,e,r){return(0===t||null!=r&&-r>=t)&&(null==e||null!=r&&e>=r)}function A(t,e){return R(t,e,0)}function j(t,e){return R(t,e,e)}function R(t,e,r){return void 0===t?r:0>t?Math.max(0,e+t):null==e?t:Math.min(e,t)}function U(t){return t}function K(t,e){return e}function P(t,e){return[e,t]}function W(){return!0}function B(t){return function(){return!t.apply(this,arguments)}}function L(t){return"string"==typeof t?JSON.stringify(t):t}function J(t,e){return t>e?1:e>t?-1:0}function T(t,e){return 0>e?(null==t.size&&t.cacheResult(),t.size+e):e}function V(t){return null==t.size&&t.cacheResult(),N(t.size),t.size}function N(t){h(1/0!==t,"Cannot perform this action with an infinite sequence.")}function Y(t,e,r,n){var i=t._cache;if(i){for(var u=i.length-1,s=0;u>=s;s++){var a=i[r?u-s:s];if(e(a[1],n?a[0]:s,t)===!1)return s+1}return s}return t.__iterateUncached(e,r)}function X(t,e,r,n){var i=t._cache;if(i){var u=i.length-1,s=0;return new mr(function(){var t=i[r?u-s:s];return s++>u?m():p(e,n?t[0]:s-1,t[1])})}return t.__iteratorUncached(e,r)
<ide> }function Z(t){if(t!==Object(t))throw new TypeError("Expected [K, V] tuple: "+t)}function F(t){var e=t.__makeSequence();return e.size=t.size,e.flip=function(){return t},e.reverse=function(){var e=t.reverse.apply(this);return e.flip=function(){return t.reverse()},e},e.has=function(e){return t.contains(e)},e.contains=function(e){return t.has(e)},e.__iterateUncached=function(e,r){var n=this;return t.__iterate(function(t,r){return e(r,t,n)!==!1},r)},e.__iteratorUncached=function(e,r){if(e===_r){var n=t.__iterator(e,r);return new mr(function(){var t=n.next();if(!t.done){var e=t.value[0];t.value[0]=t.value[1],t.value[1]=e}return t})}return t.__iterator(e===fr?cr:fr,r)},e}function G(t,e,r){var n=t.__makeSequence();return n.size=t.size,n.has=function(e){return t.has(e)},n.get=function(n,i){var u=t.get(n,Qe);return u===Qe?i:e.call(r,u,n,t)},n.__iterateUncached=function(n,i){var u=this;return t.__iterate(function(t,i,s){return n(e.call(r,t,i,s),i,u)!==!1},i)},n.__iteratorUncached=function(n,i){var u=t.__iterator(_r,i);return new mr(function(){var i=u.next();if(i.done)return i;var s=i.value,a=s[0];return p(n,a,e.call(r,s[1],a,t),i)})},n}function H(t,e){var r=t.__makeSequence();return r.size=t.size,r.reverse=function(){return t},t.flip&&(r.flip=function(){var e=F(t);return e.reverse=function(){return t.flip()},e}),r.get=function(r,n){return t.get(e?r:-1-r,n)},r.has=function(r){return t.has(e?r:-1-r)},r.contains=function(e){return t.contains(e)},r.cacheResult=function(){return t.cacheResult(),this.size=t.size,this},r.__iterate=function(e,r){var n=this;return t.__iterate(function(t,r){return e(t,r,n)},!r)},r.__iterator=function(e,r){return t.__iterator(e,!r)},r}function Q(t,e,r,n){var i=t.__makeSequence();return n&&(i.has=function(n){var i=t.get(n,Qe);return i!==Qe&&!!e.call(r,i,n,t)},i.get=function(n,i){var u=t.get(n,Qe);return u!==Qe&&e.call(r,u,n,t)?u:i}),i.__iterateUncached=function(i,u){var s=this,a=0;return t.__iterate(function(t,u,o){return e.call(r,t,u,o)?(a++,i(t,n?u:a-1,s)):void 0},u),a},i.__iteratorUncached=function(i,u){var s=t.__iterator(_r,u),a=0;
<ide> return new mr(function(){for(;;){var u=s.next();if(u.done)return u;var o=u.value,h=o[0],c=o[1];if(e.call(r,c,h,t))return p(i,n?h:a++,c,u)}})},i}function $(t,e,r,n){var i={},u=[];return t.__iterate(function(s,a){var o=e.call(r,s,a,t),h=c(o),f=n?[a,s]:s;i.hasOwnProperty(h)?u[i[h]][1].push(f):(i[h]=u.length,u.push([o,[f]]))}),Cr(u).fromEntrySeq().map(n?function(t){return Cr(t).fromEntrySeq()}:function(t){return Cr(t)})}function te(t,e){if(e>t.size)return t;0>e&&(e=0);var r=t.__makeSequence();return r.size=t.size&&Math.min(t.size,e),r.__iterateUncached=function(r,n){var i=this;if(0===e)return 0;if(n)return this.cacheResult().__iterate(r,n);var u=0;return t.__iterate(function(t,n){return++u&&r(t,n,i)!==!1&&e>u}),u},r.__iteratorUncached=function(r,n){if(n)return this.cacheResult().__iterator(r,n);var i=e&&t.__iterator(r,n),u=0;return new mr(function(){return u++>e?m():i.next()})},r}function ee(t,e,r){var n=t.__makeSequence();return n.__iterateUncached=function(n,i){var u=this;if(i)return this.cacheResult().__iterate(n,i);var s=0;return t.__iterate(function(t,i,a){return e.call(r,t,i,a)&&++s&&n(t,i,u)}),s},n.__iteratorUncached=function(n,i){var u=this;if(i)return this.cacheResult().__iterator(n,i);var s=t.__iterator(_r,i),a=!0;return new mr(function(){if(!a)return m();var t=s.next();if(t.done)return t;var i=t.value,o=i[0],h=i[1];return e.call(r,h,o,u)?n===_r?t:p(n,o,h,t):(a=!1,m())})},n}function re(t,e,r){if(0>=e)return t;var n=t.__makeSequence();return n.size=t.size&&Math.max(0,t.size-e),n.__iterateUncached=function(n,i){var u=this;if(i)return this.cacheResult().__iterate(n,i);var s=0,a=!0,o=0;return t.__iterate(function(t,i){return a&&(a=s++<e)?void 0:(o++,n(t,r?i:o-1,u))}),o},n.__iteratorUncached=function(n,i){if(i)return this.cacheResult().__iterator(n,i);var u=e&&t.__iterator(n,i),s=0,a=0;return new mr(function(){for(;e>s;)s++,u.next();var t=u.next();return r||n===fr?t:n===cr?p(n,a++,null,t):p(n,a++,t.value[1],t)})},n}function ne(t,e,r,n){var i=t.__makeSequence();return i.__iterateUncached=function(i,u){var s=this;if(u)return this.cacheResult().__iterate(i,u);
<ide> var a=!0,o=0;return t.__iterate(function(t,u,h){return a&&(a=e.call(r,t,u,h))?void 0:(o++,i(t,n?u:o-1,s))}),o},i.__iteratorUncached=function(i,u){var s=this;if(u)return this.cacheResult().__iterator(i,u);var a=t.__iterator(_r,u),o=!0,h=0;return new mr(function(){var t,u,c;do{if(t=a.next(),t.done)return n||i===fr?t:i===cr?p(i,h++,null,t):p(i,h++,t.value[1],t);var f=t.value;u=f[0],c=f[1],o&&(o=e.call(r,c,u,s))}while(o);return i===_r?t:p(i,u,c,t)})},i}function ie(t,e,r){var n=[t].concat(e),i=Pr(n);return r&&(i=i.toKeyedSeq()),i=i.flatMap(U),i.size=n.reduce(function(t,e){if(void 0!==t){var r=dr(e).size;if(null!=r)return t+r}},0),i}function ue(t,e,r){var n=t.__makeSequence();return n.__iterateUncached=function(n,i){function u(t,o){var h=this;t.__iterate(function(t,i){return(!e||e>o)&&z(t)?u(t,o+1):n(t,r?i:s++,h)===!1&&(a=!0),!a},i)}var s=0,a=!1;return u(t,0),s},n.__iteratorUncached=function(n,i){var u=t.__iterator(n,i),s=[],a=0;return new mr(function(){for(;u;){var t=u.next();if(t.done===!1){var o=t.value;if(n===_r&&(o=o[1]),e&&!(e>s.length)||!z(o))return r?t:p(n,a++,o,t);s.push(u),u=o.__iterator(n,i)}else u=s.pop()}return m()})},n}function se(t,e){var r=t.__makeSequence();return r.size=t.size&&2*t.size-1,r.__iterateUncached=function(r,n){var i=this,u=0;return t.__iterate(function(t){return(!u||r(e,u++,i)!==!1)&&r(t,u++,i)!==!1},n),u},r.__iteratorUncached=function(r,n){var i,u=t.__iterator(fr,n),s=0;return new mr(function(){return(!i||s%2)&&(i=u.next(),i.done)?i:s%2?p(r,s++,e):p(r,s++,i.value,i)})},r}function ae(t,e){return p(t,e[0],e[1])}function oe(t,e){return{node:t,index:0,__prev:e}}function he(t,e,r,n){var i=Object.create(sn);return i.size=t,i._root=e,i.__ownerID=r,i.__hash=n,i.__altered=!1,i}function ce(t,e,r){var n=u($e),i=u(tr),s=fe(t._root,t.__ownerID,0,c(e),e,r,n,i);if(!i.value)return t;var a=t.size+(n.value?r===Qe?-1:1:0);return t.__ownerID?(t.size=a,t._root=s,t.__hash=void 0,t.__altered=!0,t):s?he(a,s):nn.empty()}function fe(t,e,r,n,i,u,a,o){return t?t.update(e,r,n,i,u,a,o):u===Qe?t:(s(o),s(a),new ln(e,n,[i,u]))
<ide> if(e=Math.max(0|e,0),0===r||2===r&&!e)return this;t=A(t,this.size);var n=this.sl
<ide> return this._useKeys||(e.valueSeq=function(){return t._seq.toSeq().reverse()}),e},map:function(t,e){var r=this,n=G(this,t,e);return this._useKeys||(n.valueSeq=function(){return r._seq.toSeq().map(t,e)}),n},cacheResult:function(){return this._seq.cacheResult(),this.size=this._seq.size,this},__iterate:function(t,e){var r,n=this;return this._seq.__iterate(this._useKeys?function(e,r){return t(e,r,n)}:(r=e?V(this):0,function(i){return t(i,e?--r:r++,n)}),e)},__iterator:function(t,e){if(this._useKeys)return this._seq.__iterator(t,e);var r=this._seq.__iterator(fr,e),n=e?V(this):0;return new mr(function(){var i=r.next();return i.done?i:p(t,e?--n:n++,i.value,i)})}},{},jr);var en=function(t){this._seq=t,this.size=t.size};Xe.createClass(en,{has:function(t){return this._seq.contains(t)},cacheResult:function(){return this._seq.cacheResult(),this.size=this._seq.size,this},__iterate:function(t,e){var r=this;return this._seq.__iterate(function(e){return t(e,e,r)},e)},__iterator:function(t,e){var r=this._seq.__iterator(fr,e);return new mr(function(){var e=r.next();return e.done?e:p(t,e.value,e.value,e)})}},{},Ur);var rn=function(t){this._seq=t,this.size=t.size};Xe.createClass(rn,{entrySeq:function(){return this._seq.toSeq()},cacheResult:function(){return this._seq.cacheResult(),this.size=this._seq.size,this},__iterate:function(t,e){var r=this;return this._seq.__iterate(function(e){return e?(Z(e),t(e[1],e[0],r)):void 0},e)},__iterator:function(t,e){var r=this._seq.__iterator(fr,e);return new mr(function(){for(;;){var e=r.next();if(e.done)return e;var n=e.value;if(n)return Z(n),t===_r?e:p(t,n[0],n[1],e)}})}},{},jr);var nn=function(t){return 0===arguments.length?un.empty():t&&t.constructor===un?t:un.empty().merge(t)},un=nn;Xe.createClass(nn,{toString:function(){return this.__toString("Map {","}")},get:function(t,e){return this._root?this._root.get(0,c(t),t,e):e},set:function(t,e){return ce(this,t,e)},setIn:function(t,e){return h(t.length>0,"Requires non-empty key path."),this.updateIn(t,function(){return e})},remove:function(t){return ce(this,t,Qe)
<ide> },removeIn:function(t){return h(t.length>0,"Requires non-empty key path."),this.updateIn(t,function(){return Qe})},update:function(t,e,r){return 1===arguments.length?t(this):this.updateIn([t],e,r)},updateIn:function(t,e,r){return r||(r=e,e=void 0),0===t.length?r(this):ge(this,t,e,r,0)},clear:function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._root=null,this.__hash=void 0,this.__altered=!0,this):un.empty()},merge:function(){return me(this,null,arguments)},mergeWith:function(t){for(var e=[],r=1;arguments.length>r;r++)e[r-1]=arguments[r];return me(this,t,e)},mergeDeep:function(){return me(this,ye(null),arguments)},mergeDeepWith:function(t){for(var e=[],r=1;arguments.length>r;r++)e[r-1]=arguments[r];return me(this,ye(t),e)},cursor:function(t,e){var r=0===arguments.length||"function"==typeof t&&(e=t)?[]:Array.isArray(t)?t:[t];return Je(this,r,e)},withMutations:function(t){var e=this.asMutable();return t(e),e.wasAltered()?e.__ensureOwner(this.__ownerID):this},asMutable:function(){return this.__ownerID?this:this.__ensureOwner(new a)},asImmutable:function(){return this.__ensureOwner()},wasAltered:function(){return this.__altered},__iterator:function(t,e){return new pn(this,t,e)},__iterate:function(t,e){var r=this,n=0;return this._root&&this._root.iterate(function(e){return n++,t(e[1],e[0],r)},e),n},__ensureOwner:function(t){return t===this.__ownerID?this:t?he(this.size,this._root,t,this.__hash):(this.__ownerID=t,this.__altered=!1,this)}},{empty:function(){return mn||(mn=he(0))}},Jr);var sn=nn.prototype;sn[Ze]=sn.remove;var an=function(t,e,r){this.ownerID=t,this.bitmap=e,this.nodes=r},on=an;Xe.createClass(an,{get:function(t,e,r,n){var i=1<<((0===t?e:e>>>t)&He),u=this.bitmap;return 0===(u&i)?n:this.nodes[we(u&i-1)].get(t+Fe,e,r,n)},update:function(t,e,r,n,i,u,s){var a=(0===e?r:r>>>e)&He,o=1<<a,h=this.bitmap,c=0!==(h&o);if(!c&&i===Qe)return this;var f=we(h&o-1),_=this.nodes,l=c?_[f]:null,v=fe(l,t,e+Fe,r,n,i,u,s);if(v===l)return this;if(!c&&v&&_.length>=yn)return pe(t,_,h,a,v);if(c&&!v&&2===_.length&&_e(_[1^f]))return _[1^f];
<ide> if(c&&v&&1===_.length&&_e(v))return v;var p=t&&t===this.ownerID,m=c?v?h:h^o:h|o,y=c?v?Se(_,f,v,p):qe(_,f,p):ze(_,f,v,p);return p?(this.bitmap=m,this.nodes=y,this):new on(t,m,y)},iterate:function(t,e){for(var r=this.nodes,n=0,i=r.length-1;i>=n;n++)if(r[e?i-n:n].iterate(t,e)===!1)return!1}},{});var hn=function(t,e,r){this.ownerID=t,this.count=e,this.nodes=r},cn=hn;Xe.createClass(hn,{get:function(t,e,r,n){var i=(0===t?e:e>>>t)&He,u=this.nodes[i];return u?u.get(t+Fe,e,r,n):n},update:function(t,e,r,n,i,u,s){var a=(0===e?r:r>>>e)&He,o=i===Qe,h=this.nodes,c=h[a];if(o&&!c)return this;var f=fe(c,t,e+Fe,r,n,i,u,s);if(f===c)return this;var _=this.count;if(c){if(!f&&(_--,dn>_))return ve(t,h,_,a)}else _++;var l=t&&t===this.ownerID,v=Se(h,a,f,l);return l?(this.count=_,this.nodes=v,this):new cn(t,_,v)},iterate:function(t,e){for(var r=this.nodes,n=0,i=r.length-1;i>=n;n++){var u=r[e?i-n:n];if(u&&u.iterate(t,e)===!1)return!1}}},{});var fn=function(t,e,r){this.ownerID=t,this.hash=e,this.entries=r},_n=fn;Xe.createClass(fn,{get:function(t,e,r,n){for(var u=this.entries,s=0,a=u.length;a>s;s++)if(i(r,u[s][0]))return u[s][1];return n},update:function(t,e,r,n,u,a,h){var c=u===Qe;if(r!==this.hash)return c?this:(s(h),s(a),le(this,t,e,r,[n,u]));for(var f=this.entries,_=0,l=f.length;l>_&&!i(n,f[_][0]);_++);var v=l>_;if(c&&!v)return this;if(s(h),(c||!v)&&s(a),c&&2===l)return new ln(t,this.hash,f[1^_]);var p=t&&t===this.ownerID,m=p?f:o(f);return v?c?_===l-1?m.pop():m[_]=m.pop():m[_]=[n,u]:m.push([n,u]),p?(this.entries=m,this):new _n(t,this.hash,m)},iterate:function(t,e){for(var r=this.entries,n=0,i=r.length-1;i>=n;n++)if(t(r[e?i-n:n])===!1)return!1}},{});var ln=function(t,e,r){this.ownerID=t,this.hash=e,this.entry=r},vn=ln;Xe.createClass(ln,{get:function(t,e,r,n){return i(r,this.entry[0])?this.entry[1]:n},update:function(t,e,r,n,u,a,o){var h=u===Qe,c=i(n,this.entry[0]);return(c?u===this.entry[1]:h)?this:(s(o),h?(s(a),null):c?t&&t===this.ownerID?(this.entry[1]=u,this):new vn(t,r,[n,u]):(s(a),le(this,t,e,r,[n,u])))},iterate:function(t){return t(this.entry)
<del>}},{});var pn=function(t,e,r){this._type=e,this._reverse=r,this._stack=t._root&&oe(t._root)};Xe.createClass(pn,{next:function(){for(var t=this._type,e=this._stack;e;){var r,n=e.node,i=e.index++;if(n.entry){if(0===i)return ae(t,n.entry)}else if(n.entries){if(r=n.entries.length-1,r>=i)return ae(t,n.entries[this._reverse?r-i:i])}else if(r=n.nodes.length-1,r>=i){var u=n.nodes[this._reverse?r-i:i];if(u){if(u.entry)return ae(t,u.entry);e=this._stack=oe(u,e)}continue}e=this._stack=this._stack.__prev}return m()}},{},mr);var mn,yn=Ge/2,dn=Ge/4,gn=function(t){return 0===arguments.length?wn.empty():wn.from(t)},wn=gn;Xe.createClass(gn,{toString:function(){return this.__toString("Vector [","]")},get:function(t,e){if(t=T(this,t),0>t||t>=this.size)return e;t+=this._origin;var r=Ce(this,t);return r&&r.array[t&He]},set:function(t,e){return ke(this,t,e)},remove:function(t){return ke(this,t,Qe)},clear:function(){return 0===this.size?this:this.__ownerID?(this.size=this._origin=this._capacity=0,this._level=Fe,this._root=this._tail=null,this.__hash=void 0,this.__altered=!0,this):wn.empty()},push:function(){var t=arguments,e=this.size;return this.withMutations(function(r){Oe(r,0,e+t.length);for(var n=0;t.length>n;n++)r.set(e+n,t[n])})},pop:function(){return Oe(this,0,-1)},unshift:function(){var t=arguments;return this.withMutations(function(e){Oe(e,-t.length);for(var r=0;t.length>r;r++)e.set(r,t[r])})},shift:function(){return Oe(this,1)},merge:function(){return Ee(this,null,arguments)},mergeWith:function(t){for(var e=[],r=1;arguments.length>r;r++)e[r-1]=arguments[r];return Ee(this,t,e)},mergeDeep:function(){return Ee(this,ye(null),arguments)},mergeDeepWith:function(t){for(var e=[],r=1;arguments.length>r;r++)e[r-1]=arguments[r];return Ee(this,ye(t),e)},setSize:function(t){return Oe(this,0,t)},slice:function(t,e){var r=Xe.superCall(this,wn.prototype,"slice",[t,e]);if(r!==this){var n=this,i=n.size;r.toVector=function(){return Oe(n,0>t?Math.max(0,i+t):i?Math.min(i,t):t,null==e?i:0>e?Math.max(0,i+e):i?Math.min(i,e):e)}}return r},__iterator:function(t,e){return new In(this,t,e)
<del>},__iterate:function(t,e){var r=this,n=0,i=function(e){return t(e,n++,r)},u=Ae(this._capacity);return e?Ie(this._tail,0,u-this._origin,this._capacity-this._origin,i,e)&&Ie(this._root,this._level,-this._origin,u-this._origin,i,e):Ie(this._root,this._level,-this._origin,u-this._origin,i,e)&&Ie(this._tail,0,u-this._origin,this._capacity-this._origin,i,e),n},__ensureOwner:function(t){return t===this.__ownerID?this:t?xe(this._origin,this._capacity,this._level,this._root,this._tail,t,this.__hash):(this.__ownerID=t,this)}},{empty:function(){return bn||(bn=xe(0,0,Fe))},from:function(t){if(t&&t.constructor===wn)return t;var e=Array.isArray(t);e||(t=dr.from(t));var r=e?t.length:t.size;return 0===r?wn.empty():r>0&&Ge>r?xe(0,r,Fe,null,new zn(e?o(t):t.toArray())):wn.empty().merge(t)}},Yr);var Sn=gn.prototype;Sn[Ze]=Sn.remove,Sn.setIn=sn.setIn,Sn.removeIn=sn.removeIn,Sn.update=sn.update,Sn.updateIn=sn.updateIn,Sn.cursor=sn.cursor,Sn.withMutations=sn.withMutations,Sn.asMutable=sn.asMutable,Sn.asImmutable=sn.asImmutable,Sn.wasAltered=sn.wasAltered;var zn=function(t,e){this.array=t,this.ownerID=e},qn=zn;Xe.createClass(zn,{removeBefore:function(t,e,r){if(r===e?1<<e:0||0===this.array.length)return this;var n=r>>>e&He;if(n>=this.array.length)return new qn([],t);var i,u=0===n;if(e>0){var s=this.array[n];if(i=s&&s.removeBefore(t,e-Fe,r),i===s&&u)return this}if(u&&!i)return this;var a=De(this,t);if(!u)for(var o=0;n>o;o++)a.array[o]=void 0;return i&&(a.array[n]=i),a},removeAfter:function(t,e,r){if(r===e?1<<e:0||0===this.array.length)return this;var n=r-1>>>e&He;if(n>=this.array.length)return this;var i,u=n===this.array.length-1;if(e>0){var s=this.array[n];if(i=s&&s.removeAfter(t,e-Fe,r),i===s&&u)return this}if(u&&!i)return this;var a=De(this,t);return u||a.array.pop(),i&&(a.array[n]=i),a}},{});var In=function(t,e,r){this._type=e,this._reverse=!!r,this._maxIndex=t.size-1;var n=Ae(t._capacity),i=be(t._root&&t._root.array,t._level,-t._origin,n-t._origin-1),u=be(t._tail&&t._tail.array,0,n-t._origin,t._capacity-t._origin-1);this._stack=r?u:i,this._stack.__prev=r?i:u
<del>};Xe.createClass(In,{next:function(){for(var t=this._stack;t;){var e=t.array,r=t.index++;if(this._reverse&&(r=He-r,r>t.rawMax&&(r=t.rawMax,t.index=Ge-r)),r>=0&&Ge>r&&t.rawMax>=r){var n=e&&e[r];if(0===t.level){var i,u=this._type;return 1!==u&&(i=t.offset+(r<<t.level),this._reverse&&(i=this._maxIndex-i)),p(u,i,n)}this._stack=t=be(n&&n.array,t.level-Fe,t.offset+(r<<t.level),t.max,t)}else t=this._stack=this._stack.__prev}return m()}},{},mr);var bn,xn=function(t){return 0===arguments.length?kn.empty():t&&t.constructor===kn?t:kn.empty().unshiftAll(t)},kn=xn;Xe.createClass(xn,{toString:function(){return this.__toString("Stack [","]")},get:function(t,e){for(var r=this._head;r&&t--;)r=r.next;return r?r.value:e},peek:function(){return this._head&&this._head.value},push:function(){if(0===arguments.length)return this;for(var t=this.size+arguments.length,e=this._head,r=arguments.length-1;r>=0;r--)e={value:arguments[r],next:e};return this.__ownerID?(this.size=t,this._head=e,this.__hash=void 0,this.__altered=!0,this):je(t,e)},pushAll:function(t){if(t=dr(t),0===t.size)return this;var e=this.size,r=this._head;return t.reverse().forEach(function(t){e++,r={value:t,next:r}}),this.__ownerID?(this.size=e,this._head=r,this.__hash=void 0,this.__altered=!0,this):je(e,r)},pop:function(){return this.slice(1)},unshift:function(){return this.push.apply(this,arguments)},unshiftAll:function(t){return this.pushAll(t)},shift:function(){return this.pop.apply(this,arguments)},clear:function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._head=void 0,this.__hash=void 0,this.__altered=!0,this):kn.empty()},slice:function(t,e){if(E(t,e,this.size))return this;var r=A(t,this.size),n=j(e,this.size);if(n!==this.size)return Xe.superCall(this,kn.prototype,"slice",[t,e]);for(var i=this.size-r,u=this._head;r--;)u=u.next;return this.__ownerID?(this.size=i,this._head=u,this.__hash=void 0,this.__altered=!0,this):je(i,u)},__ensureOwner:function(t){return t===this.__ownerID?this:t?je(this.size,this._head,t,this.__hash):(this.__ownerID=t,this.__altered=!1,this)
<del>},__iterate:function(t,e){if(e)return this.toSeq().cacheResult.__iterate(t,e);for(var r=0,n=this._head;n&&t(n.value,r++,this)!==!1;)n=n.next;return r},__iterator:function(t,e){if(e)return this.toSeq().cacheResult().__iterator(t,e);var r=0,n=this._head;return new mr(function(){if(n){var e=n.value;return n=n.next,p(t,r++,e)}return m()})}},{empty:function(){return Dn||(Dn=je(0))}},Yr);var Mn=xn.prototype;Mn.withMutations=sn.withMutations,Mn.asMutable=sn.asMutable,Mn.asImmutable=sn.asImmutable,Mn.wasAltered=sn.wasAltered;var Dn,Cn=function(t){return 0===arguments.length?On.empty():t&&t.constructor===On?t:On.empty().union(t)},On=Cn;Xe.createClass(Cn,{has:function(t){return this._map.has(t)},add:function(t){var e=this._map.set(t,null);return this.__ownerID?(this.size=e.size,this._map=e,this):e===this._map?this:Re(e)},remove:function(t){var e=this._map.remove(t);return this.__ownerID?(this.size=e.size,this._map=e,this):e===this._map?this:0===e.size?On.empty():Re(e)},clear:function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._map.clear(),this):On.empty()},union:function(){var t=arguments;return 0===t.length?this:this.withMutations(function(e){for(var r=0;t.length>r;r++)dr(t[r]).forEach(function(t){return e.add(t)})})},intersect:function(){for(var t=[],e=0;arguments.length>e;e++)t[e]=arguments[e];if(0===t.length)return this;t=t.map(function(t){return dr(t)});var r=this;return this.withMutations(function(e){r.forEach(function(r){t.every(function(t){return t.contains(r)})||e.remove(r)})})},subtract:function(){for(var t=[],e=0;arguments.length>e;e++)t[e]=arguments[e];if(0===t.length)return this;t=t.map(function(t){return dr(t)});var r=this;return this.withMutations(function(e){r.forEach(function(r){t.some(function(t){return t.contains(r)})&&e.remove(r)})})},merge:function(){return this.union.apply(this,arguments)},mergeWith:function(){for(var t=[],e=1;arguments.length>e;e++)t[e-1]=arguments[e];return this.union.apply(this,t)},wasAltered:function(){return this._map.wasAltered()},__iterate:function(t,e){var r=this;
<del>return this._map.__iterate(function(e,n){return t(n,n,r)},e)},__iterator:function(t,e){return this._map.map(function(t,e){return e}).__iterator(t,e)},__ensureOwner:function(t){if(t===this.__ownerID)return this;var e=this._map.__ensureOwner(t);return t?Re(e,t):(this.__ownerID=t,this._map=e,this)}},{empty:function(){return An||(An=Re(nn.empty()))},fromKeys:function(t){return On(dr(t).flip())}},Vr);var En=Cn.prototype;En[Ze]=En.remove,En.mergeDeep=En.merge,En.mergeDeepWith=En.mergeWith,En.withMutations=sn.withMutations,En.asMutable=sn.asMutable,En.asImmutable=sn.asImmutable;var An,jn=function(t){return 0===arguments.length?Rn.empty():t&&t.constructor===Rn?t:Rn.empty().merge(t)},Rn=jn;Xe.createClass(jn,{toString:function(){return this.__toString("OrderedMap {","}")},get:function(t,e){var r=this._map.get(t);return null!=r?this._vector.get(r)[1]:e},clear:function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._map.clear(),this._vector.clear(),this):Rn.empty()},set:function(t,e){return Ke(this,t,e)},remove:function(t){return Ke(this,t,Qe)},wasAltered:function(){return this._map.wasAltered()||this._vector.wasAltered()},__iterate:function(t,e){var r=this;return this._vector.__iterate(function(e){return e&&t(e[1],e[0],r)},e)},__iterator:function(t,e){return this._vector.fromEntrySeq().__iterator(t,e)},__ensureOwner:function(t){if(t===this.__ownerID)return this;var e=this._map.__ensureOwner(t),r=this._vector.__ensureOwner(t);return t?Ue(e,r,t,this.__hash):(this.__ownerID=t,this._map=e,this._vector=r,this)}},{empty:function(){return Un||(Un=Ue(nn.empty(),gn.empty()))}},nn),jn.prototype[Ze]=jn.prototype.remove;var Un,Kn=function(t,e){var r=function(t){return this instanceof r?void(this._map=nn(t)):new r(t)},n=Object.keys(t),i=r.prototype=Object.create(Pn);i.constructor=r,e&&(i._name=e),i._defaultValues=t,i._keys=n,i.size=n.length;try{dr(t).forEach(function(t,e){Object.defineProperty(r.prototype,e,{get:function(){return this.get(e)},set:function(t){h(this.__ownerID,"Cannot set on an immutable record."),this.set(e,t)
<del>}})})}catch(u){}return r};Xe.createClass(Kn,{toString:function(){return this.__toString(this._name+" {","}")},has:function(t){return this._defaultValues.hasOwnProperty(t)},get:function(t,e){return void 0===e||this.has(t)?this._map.get(t,this._defaultValues[t]):e},clear:function(){if(this.__ownerID)return this._map.clear(),this;var t=Object.getPrototypeOf(this).constructor;return t._empty||(t._empty=Pe(this,nn.empty()))},set:function(t,e){if(!this.has(t))throw Error('Cannot set unknown key "'+t+'" on '+this._name);var r=this._map.set(t,e);return this.__ownerID||r===this._map?this:Pe(this,r)},remove:function(t){if(null==t||!this.has(t))return this;var e=this._map.remove(t);return this.__ownerID||e===this._map?this:Pe(this,e)},keys:function(){return this._map.keys()},values:function(){return this._map.values()},entries:function(){return this._map.entries()},wasAltered:function(){return this._map.wasAltered()},__iterator:function(t,e){return this._map.__iterator(t,e)},__iterate:function(t,e){var r=this;return dr(this._defaultValues).map(function(t,e){return r.get(e)}).__iterate(t,e)},__ensureOwner:function(t){if(t===this.__ownerID)return this;var e=this._map&&this._map.__ensureOwner(t);return t?Pe(this,e,t):(this.__ownerID=t,this._map=e,this)}},{},Jr);var Pn=Kn.prototype;Pn._name="Record",Pn[Ze]=Pn.remove,Pn.merge=sn.merge,Pn.mergeWith=sn.mergeWith,Pn.mergeDeep=sn.mergeDeep,Pn.mergeDeepWith=sn.mergeDeepWith,Pn.update=sn.update,Pn.updateIn=sn.updateIn,Pn.cursor=sn.cursor,Pn.withMutations=sn.withMutations,Pn.asMutable=sn.asMutable,Pn.asImmutable=sn.asImmutable;var Wn=function(t,e,r){return this instanceof Bn?(h(0!==r,"Cannot step a Range by 0"),t=t||0,null==e&&(e=1/0),t===e&&Jn?Jn:(r=null==r?1:Math.abs(r),t>e&&(r=-r),this._start=t,this._end=e,this._step=r,void(this.size=Math.max(0,Math.ceil((e-t)/r-1)+1)))):new Bn(t,e,r)},Bn=Wn;Xe.createClass(Wn,{toString:function(){return 0===this.size?"Range []":"Range [ "+this._start+"..."+this._end+(this._step>1?" by "+this._step:"")+" ]"},get:function(t,e){return this.has(t)?this._start+T(this,t)*this._step:e
<del>},contains:function(t){var e=(t-this._start)/this._step;return e>=0&&this.size>e&&e===Math.floor(e)},slice:function(t,e){return E(t,e,this.size)?this:(t=A(t,this.size),e=j(e,this.size),t>=e?Jn:new Bn(this.get(t,this._end),this.get(e,this._end),this._step))},indexOf:function(t){var e=t-this._start;if(e%this._step===0){var r=e/this._step;if(r>=0&&this.size>r)return r}return-1},lastIndexOf:function(t){return this.indexOf(t)},take:function(t){return this.slice(0,Math.max(0,t))},skip:function(t){return this.slice(Math.max(0,t))},__iterate:function(t,e){for(var r=this.size-1,n=this._step,i=e?this._start+r*n:this._start,u=0;r>=u;u++){if(t(i,u,this)===!1)return u+1;i+=e?-n:n}return u},__iterator:function(t,e){var r=this.size-1,n=this._step,i=e?this._start+r*n:this._start,u=0;return new mr(function(){var s=i;return i+=e?-n:n,u>r?m():p(t,u++,s)})},__deepEquals:function(t){return t instanceof Bn?this._start===t._start&&this._end===t._end&&this._step===t._step:Xe.superCall(this,Bn.prototype,"__deepEquals",[t])}},{},Pr);var Ln=Wn.prototype;Ln.__toJS=Ln.toArray,Ln.first=Sn.first,Ln.last=Sn.last;var Jn=Wn(0,0),Tn=function(t,e){return 0===e&&Yn?Yn:this instanceof Vn?(this._value=t,void(this.size=null==e?1/0:Math.max(0,e))):new Vn(t,e)},Vn=Tn;Xe.createClass(Tn,{toString:function(){return 0===this.size?"Repeat []":"Repeat [ "+this._value+" "+this.size+" times ]"},get:function(t,e){return this.has(t)?this._value:e},contains:function(t){return i(this._value,t)},slice:function(t,e){var r=this.size;return t=0>t?Math.max(0,r+t):Math.min(r,t),e=null==e?r:e>0?Math.min(r,e):Math.max(0,r+e),e>t?new Vn(this._value,e-t):Yn},reverse:function(){return this},indexOf:function(t){return i(this._value,t)?0:-1},lastIndexOf:function(t){return i(this._value,t)?this.size:-1},__iterate:function(t){for(var e=0;this.size>e;e++)if(t(this._value,e,this)===!1)return e+1;return e},__iterator:function(t){var e=this,r=0;return new mr(function(){return e.size>r?p(t,r++,e._value):m()})},__deepEquals:function(t){return t instanceof Vn?i(this._value,t._value):Xe.superCall(this,Vn.prototype,"__deepEquals",[t])
<del>}},{},Pr);var Nn=Tn.prototype;Nn.last=Nn.first,Nn.has=Ln.has,Nn.take=Ln.take,Nn.skip=Ln.skip,Nn.__toJS=Ln.__toJS;var Yn=new Tn(void 0,0),Xn=function(t,e,r,n){this.size=n,this._rootData=t,this._keyPath=e,this._onChange=r};Xe.createClass(Xn,{equals:function(t){return i(this.deref(),t&&("function"==typeof t.deref?t.deref():t))},deref:function(t){return this._rootData.getIn(this._keyPath,t)},get:function(t,e){if(Array.isArray(t)&&0===t.length)return this;var r=this._rootData.getIn(this._keyPath.concat(t),Qe);return r===Qe?e:Te(this,t,r)},set:function(t,e){return Ne(this,function(r){return r.set(t,e)},t)},remove:function(t){return Ne(this,function(e){return e.remove(t)},t)},clear:function(){return Ne(this,function(t){return t.clear()})},update:function(t,e,r){return 1===arguments.length?Ne(this,t):Ne(this,function(n){return n.update(t,e,r)},t)},withMutations:function(t){return Ne(this,function(e){return(e||nn.empty()).withMutations(t)})},cursor:function(t){return Array.isArray(t)&&0===t.length?this:Ve(this,t)},__iterate:function(t,e){var r=this,n=this.deref();return n&&n.__iterate?n.__iterate(function(e,n){return t(Te(r,n,e),n,r)},e):0},__iterator:function(t,e){var r=this,n=this.deref(),i=n&&n.__iterator&&n.__iterator(_r,e);return new mr(function(){if(!i)return m();var e=i.next();if(e.done)return e;var n=e.value,u=n[0],s=n[1];return p(t,u,Te(r,u,s),e)})}},{},jr);var Zn=Xn.prototype;Zn[Ze]=Zn.remove,Zn.getIn=Zn.get;var Fn=function(t,e,r,n){this.size=n,this._rootData=t,this._keyPath=e,this._onChange=r};Xe.createClass(Fn,{},{},Pr);var Gn=Fn.prototype;Gn.equals=Zn.equals,Gn.deref=Zn.deref,Gn.get=Zn.get,Gn.getIn=Zn.getIn,Gn.set=Zn.set,Gn[Ze]=Gn.remove=Zn.remove,Gn.clear=Zn.clear,Gn.update=Zn.update,Gn.withMutations=Zn.withMutations,Gn.cursor=Zn.cursor,Gn.__iterate=Zn.__iterate,Gn.__iterator=Zn.__iterator;var Hn={Iterable:dr,LazySequence:Ar,Collection:Lr,Map:nn,Vector:gn,Stack:xn,Set:Cn,OrderedMap:jn,Record:Kn,Range:Wn,Repeat:Tn,is:i,fromJS:We};return Hn}"object"==typeof exports?module.exports=t():"function"==typeof define&&define.amd?define(t):Immutable=t();
<add>}},{});var pn=function(t,e,r){this._type=e,this._reverse=r,this._stack=t._root&&oe(t._root)};Xe.createClass(pn,{next:function(){for(var t=this._type,e=this._stack;e;){var r,n=e.node,i=e.index++;if(n.entry){if(0===i)return ae(t,n.entry)}else if(n.entries){if(r=n.entries.length-1,r>=i)return ae(t,n.entries[this._reverse?r-i:i])}else if(r=n.nodes.length-1,r>=i){var u=n.nodes[this._reverse?r-i:i];if(u){if(u.entry)return ae(t,u.entry);e=this._stack=oe(u,e)}continue}e=this._stack=this._stack.__prev}return m()}},{},mr);var mn,yn=Ge/2,dn=Ge/4,gn=function(t){return 0===arguments.length?wn.empty():wn.from(t)},wn=gn;Xe.createClass(gn,{toString:function(){return this.__toString("Vector [","]")},get:function(t,e){if(t=T(this,t),0>t||t>=this.size)return e;t+=this._origin;var r=Ce(this,t);return r&&r.array[t&He]},set:function(t,e){return ke(this,t,e)},remove:function(t){return ke(this,t,Qe)},clear:function(){return 0===this.size?this:this.__ownerID?(this.size=this._origin=this._capacity=0,this._level=Fe,this._root=this._tail=null,this.__hash=void 0,this.__altered=!0,this):wn.empty()},push:function(){var t=arguments,e=this.size;return this.withMutations(function(r){Oe(r,0,e+t.length);for(var n=0;t.length>n;n++)r.set(e+n,t[n])})},pop:function(){return Oe(this,0,-1)},unshift:function(){var t=arguments;return this.withMutations(function(e){Oe(e,-t.length);for(var r=0;t.length>r;r++)e.set(r,t[r])})},shift:function(){return Oe(this,1)},merge:function(){return Ee(this,null,arguments)},mergeWith:function(t){for(var e=[],r=1;arguments.length>r;r++)e[r-1]=arguments[r];return Ee(this,t,e)},mergeDeep:function(){return Ee(this,ye(null),arguments)},mergeDeepWith:function(t){for(var e=[],r=1;arguments.length>r;r++)e[r-1]=arguments[r];return Ee(this,ye(t),e)},setSize:function(t){return Oe(this,0,t)},slice:function(t,e){var r=this.size;return E(t,e,r)?this:Oe(this,A(t,r),j(e,r))},__iterator:function(t,e){return new In(this,t,e)},__iterate:function(t,e){var r=this,n=0,i=function(e){return t(e,n++,r)},u=Ae(this._capacity);return e?Ie(this._tail,0,u-this._origin,this._capacity-this._origin,i,e)&&Ie(this._root,this._level,-this._origin,u-this._origin,i,e):Ie(this._root,this._level,-this._origin,u-this._origin,i,e)&&Ie(this._tail,0,u-this._origin,this._capacity-this._origin,i,e),n
<add>},__ensureOwner:function(t){return t===this.__ownerID?this:t?xe(this._origin,this._capacity,this._level,this._root,this._tail,t,this.__hash):(this.__ownerID=t,this)}},{empty:function(){return bn||(bn=xe(0,0,Fe))},from:function(t){if(t&&t.constructor===wn)return t;var e=Array.isArray(t);e||(t=dr.from(t));var r=e?t.length:t.size;return 0===r?wn.empty():r>0&&Ge>r?xe(0,r,Fe,null,new zn(e?o(t):t.toArray())):wn.empty().merge(t)}},Yr);var Sn=gn.prototype;Sn[Ze]=Sn.remove,Sn.setIn=sn.setIn,Sn.removeIn=sn.removeIn,Sn.update=sn.update,Sn.updateIn=sn.updateIn,Sn.cursor=sn.cursor,Sn.withMutations=sn.withMutations,Sn.asMutable=sn.asMutable,Sn.asImmutable=sn.asImmutable,Sn.wasAltered=sn.wasAltered;var zn=function(t,e){this.array=t,this.ownerID=e},qn=zn;Xe.createClass(zn,{removeBefore:function(t,e,r){if(r===e?1<<e:0||0===this.array.length)return this;var n=r>>>e&He;if(n>=this.array.length)return new qn([],t);var i,u=0===n;if(e>0){var s=this.array[n];if(i=s&&s.removeBefore(t,e-Fe,r),i===s&&u)return this}if(u&&!i)return this;var a=De(this,t);if(!u)for(var o=0;n>o;o++)a.array[o]=void 0;return i&&(a.array[n]=i),a},removeAfter:function(t,e,r){if(r===e?1<<e:0||0===this.array.length)return this;var n=r-1>>>e&He;if(n>=this.array.length)return this;var i,u=n===this.array.length-1;if(e>0){var s=this.array[n];if(i=s&&s.removeAfter(t,e-Fe,r),i===s&&u)return this}if(u&&!i)return this;var a=De(this,t);return u||a.array.pop(),i&&(a.array[n]=i),a}},{});var In=function(t,e,r){this._type=e,this._reverse=!!r,this._maxIndex=t.size-1;var n=Ae(t._capacity),i=be(t._root&&t._root.array,t._level,-t._origin,n-t._origin-1),u=be(t._tail&&t._tail.array,0,n-t._origin,t._capacity-t._origin-1);this._stack=r?u:i,this._stack.__prev=r?i:u};Xe.createClass(In,{next:function(){for(var t=this._stack;t;){var e=t.array,r=t.index++;if(this._reverse&&(r=He-r,r>t.rawMax&&(r=t.rawMax,t.index=Ge-r)),r>=0&&Ge>r&&t.rawMax>=r){var n=e&&e[r];if(0===t.level){var i,u=this._type;return 1!==u&&(i=t.offset+(r<<t.level),this._reverse&&(i=this._maxIndex-i)),p(u,i,n)}this._stack=t=be(n&&n.array,t.level-Fe,t.offset+(r<<t.level),t.max,t)
<add>}else t=this._stack=this._stack.__prev}return m()}},{},mr);var bn,xn=function(t){return 0===arguments.length?kn.empty():t&&t.constructor===kn?t:kn.empty().unshiftAll(t)},kn=xn;Xe.createClass(xn,{toString:function(){return this.__toString("Stack [","]")},get:function(t,e){for(var r=this._head;r&&t--;)r=r.next;return r?r.value:e},peek:function(){return this._head&&this._head.value},push:function(){if(0===arguments.length)return this;for(var t=this.size+arguments.length,e=this._head,r=arguments.length-1;r>=0;r--)e={value:arguments[r],next:e};return this.__ownerID?(this.size=t,this._head=e,this.__hash=void 0,this.__altered=!0,this):je(t,e)},pushAll:function(t){if(t=dr(t),0===t.size)return this;var e=this.size,r=this._head;return t.reverse().forEach(function(t){e++,r={value:t,next:r}}),this.__ownerID?(this.size=e,this._head=r,this.__hash=void 0,this.__altered=!0,this):je(e,r)},pop:function(){return this.slice(1)},unshift:function(){return this.push.apply(this,arguments)},unshiftAll:function(t){return this.pushAll(t)},shift:function(){return this.pop.apply(this,arguments)},clear:function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._head=void 0,this.__hash=void 0,this.__altered=!0,this):kn.empty()},slice:function(t,e){if(E(t,e,this.size))return this;var r=A(t,this.size),n=j(e,this.size);if(n!==this.size)return Xe.superCall(this,kn.prototype,"slice",[t,e]);for(var i=this.size-r,u=this._head;r--;)u=u.next;return this.__ownerID?(this.size=i,this._head=u,this.__hash=void 0,this.__altered=!0,this):je(i,u)},__ensureOwner:function(t){return t===this.__ownerID?this:t?je(this.size,this._head,t,this.__hash):(this.__ownerID=t,this.__altered=!1,this)},__iterate:function(t,e){if(e)return this.toSeq().cacheResult.__iterate(t,e);for(var r=0,n=this._head;n&&t(n.value,r++,this)!==!1;)n=n.next;return r},__iterator:function(t,e){if(e)return this.toSeq().cacheResult().__iterator(t,e);var r=0,n=this._head;return new mr(function(){if(n){var e=n.value;return n=n.next,p(t,r++,e)}return m()})}},{empty:function(){return Dn||(Dn=je(0))
<add>}},Yr);var Mn=xn.prototype;Mn.withMutations=sn.withMutations,Mn.asMutable=sn.asMutable,Mn.asImmutable=sn.asImmutable,Mn.wasAltered=sn.wasAltered;var Dn,Cn=function(t){return 0===arguments.length?On.empty():t&&t.constructor===On?t:On.empty().union(t)},On=Cn;Xe.createClass(Cn,{has:function(t){return this._map.has(t)},add:function(t){var e=this._map.set(t,null);return this.__ownerID?(this.size=e.size,this._map=e,this):e===this._map?this:Re(e)},remove:function(t){var e=this._map.remove(t);return this.__ownerID?(this.size=e.size,this._map=e,this):e===this._map?this:0===e.size?On.empty():Re(e)},clear:function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._map.clear(),this):On.empty()},union:function(){var t=arguments;return 0===t.length?this:this.withMutations(function(e){for(var r=0;t.length>r;r++)dr(t[r]).forEach(function(t){return e.add(t)})})},intersect:function(){for(var t=[],e=0;arguments.length>e;e++)t[e]=arguments[e];if(0===t.length)return this;t=t.map(function(t){return dr(t)});var r=this;return this.withMutations(function(e){r.forEach(function(r){t.every(function(t){return t.contains(r)})||e.remove(r)})})},subtract:function(){for(var t=[],e=0;arguments.length>e;e++)t[e]=arguments[e];if(0===t.length)return this;t=t.map(function(t){return dr(t)});var r=this;return this.withMutations(function(e){r.forEach(function(r){t.some(function(t){return t.contains(r)})&&e.remove(r)})})},merge:function(){return this.union.apply(this,arguments)},mergeWith:function(){for(var t=[],e=1;arguments.length>e;e++)t[e-1]=arguments[e];return this.union.apply(this,t)},wasAltered:function(){return this._map.wasAltered()},__iterate:function(t,e){var r=this;return this._map.__iterate(function(e,n){return t(n,n,r)},e)},__iterator:function(t,e){return this._map.map(function(t,e){return e}).__iterator(t,e)},__ensureOwner:function(t){if(t===this.__ownerID)return this;var e=this._map.__ensureOwner(t);return t?Re(e,t):(this.__ownerID=t,this._map=e,this)}},{empty:function(){return An||(An=Re(nn.empty()))},fromKeys:function(t){return On(dr(t).flip())
<add>}},Vr);var En=Cn.prototype;En[Ze]=En.remove,En.mergeDeep=En.merge,En.mergeDeepWith=En.mergeWith,En.withMutations=sn.withMutations,En.asMutable=sn.asMutable,En.asImmutable=sn.asImmutable;var An,jn=function(t){return 0===arguments.length?Rn.empty():t&&t.constructor===Rn?t:Rn.empty().merge(t)},Rn=jn;Xe.createClass(jn,{toString:function(){return this.__toString("OrderedMap {","}")},get:function(t,e){var r=this._map.get(t);return null!=r?this._vector.get(r)[1]:e},clear:function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._map.clear(),this._vector.clear(),this):Rn.empty()},set:function(t,e){return Ke(this,t,e)},remove:function(t){return Ke(this,t,Qe)},wasAltered:function(){return this._map.wasAltered()||this._vector.wasAltered()},__iterate:function(t,e){var r=this;return this._vector.__iterate(function(e){return e&&t(e[1],e[0],r)},e)},__iterator:function(t,e){return this._vector.fromEntrySeq().__iterator(t,e)},__ensureOwner:function(t){if(t===this.__ownerID)return this;var e=this._map.__ensureOwner(t),r=this._vector.__ensureOwner(t);return t?Ue(e,r,t,this.__hash):(this.__ownerID=t,this._map=e,this._vector=r,this)}},{empty:function(){return Un||(Un=Ue(nn.empty(),gn.empty()))}},nn),jn.prototype[Ze]=jn.prototype.remove;var Un,Kn=function(t,e){var r=function(t){return this instanceof r?void(this._map=nn(t)):new r(t)},n=Object.keys(t),i=r.prototype=Object.create(Pn);i.constructor=r,e&&(i._name=e),i._defaultValues=t,i._keys=n,i.size=n.length;try{dr(t).forEach(function(t,e){Object.defineProperty(r.prototype,e,{get:function(){return this.get(e)},set:function(t){h(this.__ownerID,"Cannot set on an immutable record."),this.set(e,t)}})})}catch(u){}return r};Xe.createClass(Kn,{toString:function(){return this.__toString(this._name+" {","}")},has:function(t){return this._defaultValues.hasOwnProperty(t)},get:function(t,e){return void 0===e||this.has(t)?this._map.get(t,this._defaultValues[t]):e},clear:function(){if(this.__ownerID)return this._map.clear(),this;var t=Object.getPrototypeOf(this).constructor;return t._empty||(t._empty=Pe(this,nn.empty()))
<add>},set:function(t,e){if(!this.has(t))throw Error('Cannot set unknown key "'+t+'" on '+this._name);var r=this._map.set(t,e);return this.__ownerID||r===this._map?this:Pe(this,r)},remove:function(t){if(null==t||!this.has(t))return this;var e=this._map.remove(t);return this.__ownerID||e===this._map?this:Pe(this,e)},keys:function(){return this._map.keys()},values:function(){return this._map.values()},entries:function(){return this._map.entries()},wasAltered:function(){return this._map.wasAltered()},__iterator:function(t,e){return this._map.__iterator(t,e)},__iterate:function(t,e){var r=this;return dr(this._defaultValues).map(function(t,e){return r.get(e)}).__iterate(t,e)},__ensureOwner:function(t){if(t===this.__ownerID)return this;var e=this._map&&this._map.__ensureOwner(t);return t?Pe(this,e,t):(this.__ownerID=t,this._map=e,this)}},{},Jr);var Pn=Kn.prototype;Pn._name="Record",Pn[Ze]=Pn.remove,Pn.merge=sn.merge,Pn.mergeWith=sn.mergeWith,Pn.mergeDeep=sn.mergeDeep,Pn.mergeDeepWith=sn.mergeDeepWith,Pn.update=sn.update,Pn.updateIn=sn.updateIn,Pn.cursor=sn.cursor,Pn.withMutations=sn.withMutations,Pn.asMutable=sn.asMutable,Pn.asImmutable=sn.asImmutable;var Wn=function(t,e,r){return this instanceof Bn?(h(0!==r,"Cannot step a Range by 0"),t=t||0,null==e&&(e=1/0),t===e&&Jn?Jn:(r=null==r?1:Math.abs(r),t>e&&(r=-r),this._start=t,this._end=e,this._step=r,void(this.size=Math.max(0,Math.ceil((e-t)/r-1)+1)))):new Bn(t,e,r)},Bn=Wn;Xe.createClass(Wn,{toString:function(){return 0===this.size?"Range []":"Range [ "+this._start+"..."+this._end+(this._step>1?" by "+this._step:"")+" ]"},get:function(t,e){return this.has(t)?this._start+T(this,t)*this._step:e},contains:function(t){var e=(t-this._start)/this._step;return e>=0&&this.size>e&&e===Math.floor(e)},slice:function(t,e){return E(t,e,this.size)?this:(t=A(t,this.size),e=j(e,this.size),t>=e?Jn:new Bn(this.get(t,this._end),this.get(e,this._end),this._step))},indexOf:function(t){var e=t-this._start;if(e%this._step===0){var r=e/this._step;if(r>=0&&this.size>r)return r}return-1},lastIndexOf:function(t){return this.indexOf(t)
<add>},take:function(t){return this.slice(0,Math.max(0,t))},skip:function(t){return this.slice(Math.max(0,t))},__iterate:function(t,e){for(var r=this.size-1,n=this._step,i=e?this._start+r*n:this._start,u=0;r>=u;u++){if(t(i,u,this)===!1)return u+1;i+=e?-n:n}return u},__iterator:function(t,e){var r=this.size-1,n=this._step,i=e?this._start+r*n:this._start,u=0;return new mr(function(){var s=i;return i+=e?-n:n,u>r?m():p(t,u++,s)})},__deepEquals:function(t){return t instanceof Bn?this._start===t._start&&this._end===t._end&&this._step===t._step:Xe.superCall(this,Bn.prototype,"__deepEquals",[t])}},{},Pr);var Ln=Wn.prototype;Ln.__toJS=Ln.toArray,Ln.first=Sn.first,Ln.last=Sn.last;var Jn=Wn(0,0),Tn=function(t,e){return 0===e&&Yn?Yn:this instanceof Vn?(this._value=t,void(this.size=null==e?1/0:Math.max(0,e))):new Vn(t,e)},Vn=Tn;Xe.createClass(Tn,{toString:function(){return 0===this.size?"Repeat []":"Repeat [ "+this._value+" "+this.size+" times ]"},get:function(t,e){return this.has(t)?this._value:e},contains:function(t){return i(this._value,t)},slice:function(t,e){var r=this.size;return t=0>t?Math.max(0,r+t):Math.min(r,t),e=null==e?r:e>0?Math.min(r,e):Math.max(0,r+e),e>t?new Vn(this._value,e-t):Yn},reverse:function(){return this},indexOf:function(t){return i(this._value,t)?0:-1},lastIndexOf:function(t){return i(this._value,t)?this.size:-1},__iterate:function(t){for(var e=0;this.size>e;e++)if(t(this._value,e,this)===!1)return e+1;return e},__iterator:function(t){var e=this,r=0;return new mr(function(){return e.size>r?p(t,r++,e._value):m()})},__deepEquals:function(t){return t instanceof Vn?i(this._value,t._value):Xe.superCall(this,Vn.prototype,"__deepEquals",[t])}},{},Pr);var Nn=Tn.prototype;Nn.last=Nn.first,Nn.has=Ln.has,Nn.take=Ln.take,Nn.skip=Ln.skip,Nn.__toJS=Ln.__toJS;var Yn=new Tn(void 0,0),Xn=function(t,e,r,n){this.size=n,this._rootData=t,this._keyPath=e,this._onChange=r};Xe.createClass(Xn,{equals:function(t){return i(this.deref(),t&&("function"==typeof t.deref?t.deref():t))},deref:function(t){return this._rootData.getIn(this._keyPath,t)
<add>},get:function(t,e){if(Array.isArray(t)&&0===t.length)return this;var r=this._rootData.getIn(this._keyPath.concat(t),Qe);return r===Qe?e:Te(this,t,r)},set:function(t,e){return Ne(this,function(r){return r.set(t,e)},t)},remove:function(t){return Ne(this,function(e){return e.remove(t)},t)},clear:function(){return Ne(this,function(t){return t.clear()})},update:function(t,e,r){return 1===arguments.length?Ne(this,t):Ne(this,function(n){return n.update(t,e,r)},t)},withMutations:function(t){return Ne(this,function(e){return(e||nn.empty()).withMutations(t)})},cursor:function(t){return Array.isArray(t)&&0===t.length?this:Ve(this,t)},__iterate:function(t,e){var r=this,n=this.deref();return n&&n.__iterate?n.__iterate(function(e,n){return t(Te(r,n,e),n,r)},e):0},__iterator:function(t,e){var r=this,n=this.deref(),i=n&&n.__iterator&&n.__iterator(_r,e);return new mr(function(){if(!i)return m();var e=i.next();if(e.done)return e;var n=e.value,u=n[0],s=n[1];return p(t,u,Te(r,u,s),e)})}},{},jr);var Zn=Xn.prototype;Zn[Ze]=Zn.remove,Zn.getIn=Zn.get;var Fn=function(t,e,r,n){this.size=n,this._rootData=t,this._keyPath=e,this._onChange=r};Xe.createClass(Fn,{},{},Pr);var Gn=Fn.prototype;Gn.equals=Zn.equals,Gn.deref=Zn.deref,Gn.get=Zn.get,Gn.getIn=Zn.getIn,Gn.set=Zn.set,Gn[Ze]=Gn.remove=Zn.remove,Gn.clear=Zn.clear,Gn.update=Zn.update,Gn.withMutations=Zn.withMutations,Gn.cursor=Zn.cursor,Gn.__iterate=Zn.__iterate,Gn.__iterator=Zn.__iterator;var Hn={Iterable:dr,LazySequence:Ar,Collection:Lr,Map:nn,Vector:gn,Stack:xn,Set:Cn,OrderedMap:jn,Record:Kn,Range:Wn,Repeat:Tn,is:i,fromJS:We};return Hn}"object"==typeof exports?module.exports=t():"function"==typeof define&&define.amd?define(t):Immutable=t();
<ide>\ No newline at end of file
<ide><path>src/Sequence.js
<ide> function resolveEnd(end, size) {
<ide> }
<ide>
<ide> function resolveIndex(index, size, defaultIndex) {
<del> return index == null ?
<add> return index === undefined ?
<ide> defaultIndex :
<ide> index < 0 ?
<ide> Math.max(0, size + index) :
<ide><path>src/Vector.js
<ide> import "Map"
<ide> import "TrieUtils"
<ide> import "Iterator"
<ide> /* global Iterable, IndexedCollection, wrapIndex,
<add> wholeSlice, resolveBegin, resolveEnd,
<ide> MapPrototype, mergeIntoCollectionWith, deepMerger,
<ide> DELETE, SHIFT, SIZE, MASK, NOT_SET, DID_ALTER, OwnerID, MakeRef,
<ide> SetRef, arrCopy, Iterator, iteratorValue, iteratorDone */
<ide> class Vector extends IndexedCollection {
<ide> // @pragma Iteration
<ide>
<ide> slice(begin, end) {
<del> var sliceSequence = super.slice(begin, end);
<del> // Optimize the case of vector.slice(b, e).toVector()
<del> if (sliceSequence !== this) {
<del> var vector = this;
<del> var size = vector.size;
<del> sliceSequence.toVector = () => setVectorBounds(
<del> vector,
<del> begin < 0 ? Math.max(0, size + begin) : size ? Math.min(size, begin) : begin,
<del> end == null ? size : end < 0 ? Math.max(0, size + end) : size ? Math.min(size, end) : end
<del> );
<del> }
<del> return sliceSequence;
<add> var size = this.size;
<add> if (wholeSlice(begin, end, size)) {
<add> return this;
<add> }
<add> return setVectorBounds(
<add> this,
<add> resolveBegin(begin, size),
<add> resolveEnd(end, size)
<add> );
<ide> }
<ide>
<ide> __iterator(type, reverse) { | 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.