From 89ed3910294bb0d22c7575c5001d0024a594c8c1 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Wed, 9 Jul 2025 11:41:35 +0200 Subject: [PATCH 01/10] Lint README.md --- README.md | 119 ++++++++++++++++++++++++++++++++---------------------- 1 file changed, 71 insertions(+), 48 deletions(-) diff --git a/README.md b/README.md index b3ae11de9..01a7a7f9e 100644 --- a/README.md +++ b/README.md @@ -2,20 +2,22 @@ +- [Specification and Bindings for Swift Binary Protocol](#specification-and-bindings-for-swift-binary-protocol) - [Installing sbp2json, json2sbp, json2json and related tools](#installing-sbp2json-json2sbp-json2json-and-related-tools) - [Building / installing](#building--installing) - * [Using Docker](#using-docker) - + [Fetching the prebuilt image from DockerHub](#fetching-the-prebuilt-image-from-dockerhub) - + [Creating your own image](#creating-your-own-image) - + [Using the docker image](#using-the-docker-image) - * [Installing from package managers](#installing-from-package-managers) - * [Installing development Python versions](#installing-development-python-versions) - * [Adding development version as a pip dependency](#adding-development-version-as-a-pip-dependency) - * [Installing from source](#installing-from-source) + - [Using Docker](#using-docker) + - [Fetching the prebuilt image from DockerHub](#fetching-the-prebuilt-image-from-dockerhub) + - [Creating your own image](#creating-your-own-image) + - [Using the docker image](#using-the-docker-image) + - [Installing from package managers](#installing-from-package-managers) + - [Installing development Python versions](#installing-development-python-versions) + - [Adding development version as a pip dependency](#adding-development-version-as-a-pip-dependency) + - [Installing from source](#installing-from-source) - [SBP Development Procedures](#sbp-development-procedures) - [SBP Protocol Specification](#sbp-protocol-specification) - [JSON Schema Definitions](#json-schema-definitions) - [Kaitai Struct Format Descriptions](#kaitai-struct-format-descriptions) + - [Notes on python bindings](#notes-on-python-bindings) - [LICENSE](#license) @@ -32,19 +34,19 @@ messages used with SBP, a compiler for generating message bindings, and client libraries in a variety of languages. This repository is organized into the following directory structure: -* [`docs`](./docs): Protocol documentation and message definitions. -* [`spec`](./spec): Machine readable protocol specification in +- [`docs`](./docs): Protocol documentation and message definitions. +- [`spec`](./spec): Machine readable protocol specification in [YAML](http://en.wikipedia.org/wiki/YAML). -* [`generator`](./generator): Simple, template-based generator for +- [`generator`](./generator): Simple, template-based generator for different languages. -* [`python`](./python): Python client and examples. -* [`c`](./c): C client library and examples. -* [`haskell`](./haskell): Haskell client and examples. -* [`java`](./java): Java client library and examples. -* [`javascript`](./javascript): JavaScript client library and examples. -* [`rust`](./rust): Rust client library and examples. -* [`sbpjson`](./sbpjson): Tools for parsing SBP-JSON. -* [`kaitai`](./kaitai): Kaitai Struct Format Description and generated code. +- [`python`](./python): Python client and examples. +- [`c`](./c): C client library and examples. +- [`haskell`](./haskell): Haskell client and examples. +- [`java`](./java): Java client library and examples. +- [`javascript`](./javascript): JavaScript client library and examples. +- [`rust`](./rust): Rust client library and examples. +- [`sbpjson`](./sbpjson): Tools for parsing SBP-JSON. +- [`kaitai`](./kaitai): Kaitai Struct Format Description and generated code. Except for the `generator`, all of the above are generated and should not be modified directly. @@ -72,7 +74,7 @@ your platform. To install from source, you can use Rust's cargo tool (first [install Rust](https://www.rust-lang.org/tools/install)), then run: -``` +```sh cargo install --git https://github.com/swift-nav/libsbp.git --bins ``` @@ -87,13 +89,13 @@ tool as well as a `sbp2prettyjson` tool. Finally, a Python version of the `sbp2json` tool exists, which is installable on any platform that supports Python via pip, e.g.: -``` +```sh pip3 install sbp ``` The tool can then be invoked as follows: -``` +```sh python3 -m sbp2json #egg=sbp&subdirectory=python" ``` Or add this to `requirements.txt`: -``` + +```sh git+https://github.com/swift-nav/libsbp@#egg=sbp&subdirectory=python ``` ### Installing from source + You can build one binding at a time or update all at once: -``` +```sh make python ``` or -``` +```sh make all ``` are both valid. To see a list of all valid targets, run `make help`. **Python version notes:** + 1. By default the Python targets `make python` and `make test-python` (as well as `make all`) run tests on all Python versions officially supported by *the libsbp Python bindings*, currently **3.6-3.9**, skipping any versions not @@ -281,19 +304,19 @@ respectively. The Kaitai Struct format description files can also potentially be used to generate bindings for the following targets: -* graphviz -* csharp -* rust -* java -* go -* cpp_stl -* php -* lua -* nim -* html -* ruby -* construct -* javascript +- graphviz +- csharp +- rust +- java +- go +- cpp_stl +- php +- lua +- nim +- html +- ruby +- construct +- javascript ### Notes on python bindings From 85391cabe81f244472683f1c418bbe1364783e8f Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Wed, 9 Jul 2025 11:48:52 +0200 Subject: [PATCH 02/10] Update --- HOWTO.md | 192 ++++++++++++++++++++++++++++++------------------------- 1 file changed, 105 insertions(+), 87 deletions(-) diff --git a/HOWTO.md b/HOWTO.md index 41d068777..6a2cd3b39 100644 --- a/HOWTO.md +++ b/HOWTO.md @@ -1,23 +1,26 @@ -libsbp Development Procedures -============================= +# libsbp Development Procedures -- [Adding and Testing New Messages](#adding-and-testing-new-messages) - * [Generating missing tests](#generating-missing-tests) -- [Message Guidelines](#message-guidelines) -- [Releasing New Versions of the Library](#releasing-new-versions-of-the-library) - * [Using Docker](#using-docker) - * [The Process](#the-process) -- [Installing QuickType](#installing-quicktype) -- [Distributing Rust](#distributing-rust) -- [Distributing Python](#distributing-python) - * [Troubleshooting](#troubleshooting) - + [Error: `!!! No Python wheel (.whl) file found...`](#error--no-python-wheel-whl-file-found) - + [Tox error: `ERROR: FAIL could not package project`](#tox-error-error-fail-could-not-package-project) - + [Tox error: `ERROR: cowardly refusing to delete envdir`](#tox-error-error-cowardly-refusing-to-delete-envdir) -- [Distributing Java](#distributing-java) -- [Contributions](#contributions) +- [libsbp Development Procedures](#libsbp-development-procedures) + - [Adding and Testing New Messages](#adding-and-testing-new-messages) + - [Generating missing tests](#generating-missing-tests) + - [Existing Messages](#existing-messages) + - [New Messages](#new-messages) + - [Message Guidelines](#message-guidelines) + - [Releasing New Versions of the Library](#releasing-new-versions-of-the-library) + - [Using Docker](#using-docker) + - [The Process](#the-process) + - [Installing QuickType](#installing-quicktype) + - [Distributing Rust](#distributing-rust) + - [Distributing Python](#distributing-python) + - [Troubleshooting](#troubleshooting) + - [Error: `!!! No Python wheel (.whl) file found...`](#error--no-python-wheel-whl-file-found) + - [Tox error: `ERROR: FAIL could not package project`](#tox-error-error-fail-could-not-package-project) + - [Tox error: `ERROR: cowardly refusing to delete envdir`](#tox-error-error-cowardly-refusing-to-delete-envdir) + - [Distributing Java](#distributing-java) + - [Generating GPG key for Java](#generating-gpg-key-for-java) + - [Contributions](#contributions) @@ -25,7 +28,7 @@ This document summarizes some practices around contributions to this library. These instructions don't come with a warranty yet, so please feel free to update it to mirror reality. -# Adding and Testing New Messages +## Adding and Testing New Messages Adding new SBP messages is currently a very organic, social process. This is likely to change in the future. @@ -41,8 +44,8 @@ process. This is likely to change in the future. by the corresponding number of new messages. 3. If adding a new "group" of messages (adding a new YAML file to - `spec/yaml/swiftnav/sbp`), add the new message group to - `python/sbp/table.py` and `javascript/sbp/msg.js`. + `spec/yaml/swiftnav/sbp`), add the new message group to + `python/sbp/table.py` and `javascript/sbp/msg.js`. 4. Generate new clients and documentation by running `make all`. Verify that the generated code, which isn't too complicated, @@ -66,14 +69,16 @@ process. This is likely to change in the future. new message, deploy the updated Python client first, and then the C client. We haven't quite decided on the details of this process. -## Generating missing tests +### Generating missing tests + There are some tools that can assist with generating YAML based tests, like the ones already defined in the [`test`](spec/tests/yaml/swiftnav/sbp) directory. These YAML files are used to generate tests in the various languages that libsbp supports, to ensure that serializing and deserializing messages works as intended -### Existing Messages +#### Existing Messages + For messages that are already being sent (eg: by Starling, or by a Piksi), the `generator/missing.py` script can be used to connect to a socket and automatically generate tests for any received messages that do not already have @@ -81,11 +86,12 @@ tests. Usage for `missing`: -```shell +```sh python missing.py --host [HOST] --port [PORT] ``` -### New Messages +#### New Messages + The `json2test` script can be used to automatically generate tests for newly defined messages. The json2test script uses [uv](https://docs.astral.sh/uv/) to manage its dependencies, which can be installed following the instructions on that @@ -106,7 +112,7 @@ form: And then generate a test for using `json2test` with: -```shell +```sh uv -n run json2test.py --input heartbeat.json --output ../spec/tests/yaml/swiftnav/sbp/system/test_MsgHeartbeat.yaml ``` @@ -118,14 +124,14 @@ caching is turned off. Usage for `json2test` -```shell +```sh uv -n run json2test --input [PATH_TO_JSON_IN] --output [PATH_TO_YAML_OUT] ``` -* The `msg_type` can also be provided through a CLI parameter, with `--msg-id +- The `msg_type` can also be provided through a CLI parameter, with `--msg-id [MESSAGE_ID]` -# Message Guidelines +## Message Guidelines Some thoughts to consider when adding a new message: @@ -156,23 +162,27 @@ Some thoughts to consider when adding a new message: contents is fine, as long as the migrating consumers is a well-understood process. -# Releasing New Versions of the Library +## Releasing New Versions of the Library -## Using Docker +### Using Docker It's highly recommended to use the docker container to run the release process, the docker container can be pulled from DockerHub and launched via this command: - docker run -v $PWD:/mnt/workspace -i -t swiftnav/libsbp-build:2025-02-10 +```sh +docker run -v $PWD:/mnt/workspace -i -t swiftnav/libsbp-build:2025-02-10 +``` You can invoke individual stages like so: - docker run -v $PWD:/mnt/workspace -i -t swiftnav/libsbp-build:2025-02-10 \ - /bin/bash -c "make python" +```sh +docker run -v $PWD:/mnt/workspace -i -t swiftnav/libsbp-build:2025-02-10 \ + /bin/bash -c "make python" +``` Check this [link](https://hub.docker.com/r/swiftnav/libsbp-build/tags) for newer tags. -## The Process +### The Process Oh boy, so you've decided to release a new version of libsbp. It's recommended this process is performed using the above docker container. You'll likely want @@ -181,27 +191,27 @@ inside the container (so you don't have to setup git inside the docker container This process describes running `make ` in multiple places. These targets will both regenerate the language bindings and then build and run any test suites. -Skipping tests should not be done by default, but most languages have a "gen" target -available - `make gen-` - which will only regenerate the bindings without +Skipping tests should not be done by default, but most languages have a "gen" target +available - `make gen-` - which will only regenerate the bindings without running tests. This can be used to split or speed up the process should any errors occur and something needs to be repeated. 1. It's easiest to do this on the master branch. Start by tagging the release version: - ```shell + ```sh # Produces most recent tag (e.g., v2.7.5) git describe --abbrev=0 --tags # Increment that value, create a new one (e.g, v2.7.6) git tag -a -m "Version of libsbp." ``` - For library versions (i.e. ``) we try to follow + For library versions (i.e. ``) we try to follow [SemVer](https://semver.org/). For message versioning refer to this [document on versioning](./VERSIONING.md). - + 2. Make sure that the repo is reported as clean, e.g. - ```shell + ```sh git describe --tags --dirty --always ``` @@ -210,7 +220,7 @@ and something needs to be repeated. 3. Run make targets for each language and re-tag. For python: - ```shell + ```sh make python git add python/sbp/RELEASE-VERSION git commit -m 'Release ' @@ -220,22 +230,22 @@ and something needs to be repeated. For Java, jsonschema, and Protobuf (these should not require bumping the git tag, unless the generated files are out of date): - ```shell + ```sh make java jsonschema protobuf ``` For C, Haskell and JavaScript (JavaScript, make needs to be run twice to update the package information): - ```shell + ```sh make c haskell javascript rust git add c/include/libsbp/version.h haskell/sbp.cabal rust/sbp/Cargo.toml git commit --amend -a -m 'Release ' git tag -f -a INCREMENTED_TAG -m "Version INCREMENTED_TAG of libsbp." ``` - For JavaScript, needs to be run twice to update the package information - ```shell + + ```sh make javascript make javascript git add javascript/sbp/RELEASE-VERSION package.json package-lock.json @@ -244,7 +254,7 @@ and something needs to be repeated. For Kaitai - ```shell + ```sh make kaitai git add kaitai/ksy/sbp.ksy git commit --amend -a -m 'Release ' @@ -252,17 +262,17 @@ and something needs to be repeated. 4. Build the docs: - ```shell + ```sh make docs ``` - + Be sure to inspect the [docs](docs/sbp.pdf) manually, as LaTeX sometimes needs to be run multiple - times to compile properly. If something looks off with the docs, run `make docs` repeatedly until + times to compile properly. If something looks off with the docs, run `make docs` repeatedly until the issue is fixed. Then commit the docs and re-tag: - ```shell + ```sh git add docs/sbp.pdf git commit --amend -a -m 'Release ' git tag -f -a INCREMENTED_TAG -m "Version INCREMENTED_TAG of libsbp." @@ -281,7 +291,8 @@ and something needs to be repeated. documentation are consistent. 7. Push the release to GitHub: - ```shell + + ```sh git push origin master ``` @@ -302,7 +313,7 @@ and something needs to be repeated. Again, javascript needs to be built twice to get the correct package versions - ``` + ```sh git commit --allow-empty -m "prep for next release #no_auto_pr" make all make javascript @@ -311,28 +322,28 @@ and something needs to be repeated. git push origin master ``` -9. Distribute release packages. You can attempt to run all releases - with `make dist` -- this will likely not work through... it is - advisable to run each dist target separately. In particular: +10. Distribute release packages. You can attempt to run all releases + with `make dist` -- this will likely not work through... it is + advisable to run each dist target separately. In particular: - - `make dist-javascript` - - `make dist-haskell` - - `make dist-rust` (see section on Rust below) - - `make dist-python` (see section on Python below) - - `make dist-java` (see section on Java below) + - `make dist-javascript` + - `make dist-haskell` + - `make dist-rust` (see section on Rust below) + - `make dist-python` (see section on Python below) + - `make dist-java` (see section on Java below) - You may need credentials on the appropriate package repositories. Ignore the - GPG error in `stack`, the package will get uploaded correctly anyway. If - the release is a Python only change it may be appropriate to just publish to - PyPI with `make dist-python` (see section on Python below) -- we typically - update all other supported languages when we make an official firmware - release. + You may need credentials on the appropriate package repositories. Ignore the + GPG error in `stack`, the package will get uploaded correctly anyway. If + the release is a Python only change it may be appropriate to just publish to + PyPI with `make dist-python` (see section on Python below) -- we typically + update all other supported languages when we make an official firmware + release. -10. Releases are not only never perfect, they never really end. Please +11. Releases are not only never perfect, they never really end. Please pay special attention to any downstream projects or users that may have issues or regressions as a consequence of the release version. -# Installing QuickType +## Installing QuickType For web clients we generate JSON schema definitions of the SBP message. This allows web clients to build "native" objects out of SBP JSON. @@ -343,36 +354,36 @@ In order to run the `make quicktype-*` target you need to install the quicktype tool first. No particular version of this tool is required at the moment. -# Distributing Rust +## Distributing Rust To distribute Rust. Use the `cargo-release` tool: -``` +```sh cargo install cargo-release ``` Once you have logged in to crates.io with `cargo`: -```shell +```sh cargo release --allow-branch HEAD --execute ``` Then rollback any commits that are created: -``` +```sh git reset --hard v ``` -# Distributing Python +## Distributing Python The build of the libsbp wheel can be done via the `libsbp-build` container described above. You must have the correct token set in your environment to publish to PyPI. -## Troubleshooting +### Troubleshooting -### Error: `!!! No Python wheel (.whl) file found...` +#### Error: `!!! No Python wheel (.whl) file found...` This usually means the git checkout you're building from is not in a "clean" state. The build scripts will use the git command `git describe --tag --always --dirty` to generate @@ -380,47 +391,55 @@ a version. Either temporarily force update the tag with `git tag -f vM.N.X` (do push this unintentionally) and/or make sure you're submodule are up-to-date with `git submodule update --init --checkout --recursive`. -### Tox error: `ERROR: FAIL could not package project` +#### Tox error: `ERROR: FAIL could not package project` Tox needs to be run with the Python it was installed with (and apparently must run with Python 2) otherwise you'll get an error similar to: +```sh ERROR: FAIL could not package project - v = InvocationError('/home/ubuntu/dev/libsbp/python/.tox/.tox/bin/python setup.py sdist --formats=zip --dist-dir /home/ubuntu/dev/libsbp/python/.tox/dist', -11) +``` Tox also seems to have issues interacting with conda environments. The easiest way to work around this is to remove conda from your path and make sure tox is installed with a Python2 version of the interpreter. -### Tox error: `ERROR: cowardly refusing to delete envdir` +#### Tox error: `ERROR: cowardly refusing to delete envdir` Tox may fail with the following error: +```sh ERROR: cowardly refusing to delete `envdir` (it does not look like a virtualenv): /home/ubuntu/dev/libsbp/python/.tox/py38-nojit +``` -There's an open tox issue for this: https://github.com/tox-dev/tox/issues/1354 +There's an open tox issue for this: -- the only workaround that resolved this was to downgrade tox: +```sh pip install --upgrade --force-reinstall tox==3.12.1 +``` -# Distributing Java +## Distributing Java To distribute java, ensure you have the correct credentials and prerequisites + - Gradle 7+ - gradle.properties - Sonatype deployer account - Your own GPG key -## Generating GPG key for Java +### Generating GPG key for Java SonaType open source repo requires a GPG key for signatures. Generate GPG key via: -```shell +```sh gpg --gen-key gpg --export-secret-keys >keys.gpg ``` Export your public key -``` + +```sh gpg --export -a > pub.key ``` @@ -428,7 +447,7 @@ Go to [https://keyserver.ubuntu.com/#submitKey](https://keyserver.ubuntu.com/#su To locate the value for `signing.keyId` (needed below) run: -```shell +```sh ❯ gpg --list-keys --keyid-format short (base) /home/ubuntu/.gnupg/pubring.kbx ------------------------------- @@ -442,8 +461,7 @@ The `signing.keyId` value to use from above is `BB59B113`. The `/keys` folder to should map to location where your gpg key will be stored. Then, create `gradle.properties` in the `java` directory as follows: - -```shell +```sh # last 8 digit of gpg key signing.keyId=xxx # password for gpg key @@ -466,7 +484,7 @@ For more info see: Date: Wed, 9 Jul 2025 14:01:26 +0200 Subject: [PATCH 03/10] Test --- spec/yaml/swiftnav/sbp/integrity.yaml | 129 +++++++++++++++++++++++++- 1 file changed, 126 insertions(+), 3 deletions(-) diff --git a/spec/yaml/swiftnav/sbp/integrity.yaml b/spec/yaml/swiftnav/sbp/integrity.yaml index 3513885bd..356f3d5d7 100644 --- a/spec/yaml/swiftnav/sbp/integrity.yaml +++ b/spec/yaml/swiftnav/sbp/integrity.yaml @@ -41,8 +41,128 @@ definitions: type: u8 desc: Chain and type of flag. - - MSG_SSR_FLAG_HIGH_LEVEL: + - MSG_SSR_FLAG_HIGH_LEVEL_DEP_A: id: 0x0BB9 + short_desc: Deprecated + desc: Deprecated. + public: false + replaced_by: + - MSG_SSR_FLAG_HIGH_LEVEL + fields: + - obs_time: + type: GPSTimeSec + desc: GNSS reference time of the observation used to generate the flag. + - corr_time: + type: GPSTimeSec + desc: GNSS reference time of the correction associated to the flag. + - ssr_sol_id: + type: u8 + desc: SSR Solution ID. + - tile_set_id: + type: u16 + desc: Unique identifier of the set this tile belongs to. + - tile_id: + type: u16 + desc: Unique identifier of this tile in the tile set. + - chain_id: + type: u8 + desc: Chain and type of flag. + - use_gps_sat: + type: u8 + desc: Use GPS satellites. + fields: + - 0-2: + desc: Use GPS satellites. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - use_gal_sat: + type: u8 + desc: Use GAL satellites. + fields: + - 0-2: + desc: Use GAL satellites. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - use_bds_sat: + type: u8 + desc: Use BDS satellites. + fields: + - 0-2: + desc: Use BDS satellites. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - use_qzss_sat: + type: u8 + desc: Use QZSS satellites. + fields: + - 0-2: + desc: Use QZSS satellites. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - reserved: + type: array + size: 5 + fill: u8 + desc: Reserved + - use_tropo_grid_points: + type: u8 + desc: Use tropo grid points. + fields: + - 0-2: + desc: Use tropo grid points. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - use_iono_grid_points: + type: u8 + desc: Use iono grid points. + fields: + - 0-2: + desc: Use iono grid points. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - use_iono_tile_sat_los: + type: u8 + desc: Use iono tile satellite LoS. + fields: + - 0-2: + desc: Use iono tile satellite LoS. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + - use_iono_grid_point_sat_los: + type: u8 + desc: Use iono grid point satellite LoS. + fields: + - 0-2: + desc: Use iono grid point satellite LoS. + values: + - 0: Nominal + - 1: Warning + - 2: Alert + - 3: Not monitored + + - MSG_SSR_FLAG_HIGH_LEVEL: + id: 0x0BBA short_desc: High level integrity flags desc: > Integrity monitoring flags for multiple aggregated elements. @@ -82,9 +202,12 @@ definitions: - obs_time: type: GPSTimeSec desc: GNSS reference time of the observation used to generate the flag. - - corr_time: + - atmo_corr_time: type: GPSTimeSec - desc: GNSS reference time of the correction associated to the flag. + desc: GNSS reference time of the atmospheric correction associated to the flag. + - sat_corr_time: + type: GPSTimeSec + desc: GNSS reference time of the satellite correction associated to the flag. - ssr_sol_id: type: u8 desc: SSR Solution ID. From 03fda3bb5cc129f65d2471b0736de58db2a669e8 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Wed, 9 Jul 2025 16:24:19 +0200 Subject: [PATCH 04/10] make all --- README.md | 38 +- c/README.md | 6 +- c/include/libsbp/cpp/message_traits.h | 38 + c/include/libsbp/integrity.h | 1 + .../integrity/MSG_SSR_FLAG_HIGH_LEVEL.h | 9 +- .../integrity/MSG_SSR_FLAG_HIGH_LEVEL_DEP_A.h | 254 +++++ c/include/libsbp/integrity_macros.h | 189 +++- c/include/libsbp/sbp_msg.h | 13 + c/include/libsbp/sbp_msg_type.h | 5 +- c/src/include/libsbp/internal/integrity.h | 20 + c/src/integrity.c | 252 ++++- c/src/sbp.c | 4 +- ..._check_sbp_integrity_MsgSsrFlagHighLevel.c | 54 +- ...ck_sbp_integrity_MsgSsrFlagHighLevelDepA.c | 313 ++++++ c/test/check_main.c | 2 + c/test/check_suites.h | 1 + ...check_sbp_integrity_MsgSsrFlagHighLevel.cc | 71 +- ...k_sbp_integrity_MsgSsrFlagHighLevelDepA.cc | 962 ++++++++++++++++++ docs/sbp.pdf | Bin 567691 -> 567808 bytes haskell/src/SwiftNav/SBP/Integrity.hs | 96 +- haskell/src/SwiftNav/SBP/Msg.hs | 6 + .../com/swiftnav/sbp/client/MessageTable.java | 3 + .../sbp/integrity/MsgSsrFlagHighLevel.java | 22 +- .../integrity/MsgSsrFlagHighLevelDepA.java | 158 +++ ...integrity_MsgSsrFlagHighLevelDepATest.java | 285 ++++++ ...sbp_integrity_MsgSsrFlagHighLevelTest.java | 52 +- javascript/sbp/integrity.js | 86 +- jsonschema/MsgSsrFlagHighLevel.json | 6 +- kaitai/ksy/integrity.ksy | 77 +- kaitai/ksy/sbp.ksy | 6 +- kaitai/perl/KaitaiSbp/Integrity.pm | 134 ++- kaitai/perl/KaitaiSbp/Sbp.pm | 10 +- kaitai/perl/KaitaiSbp/Table.pm | 3 +- ..._check_sbp_integrity_MsgSsrFlagHighLevel.t | 14 +- ...ck_sbp_integrity_MsgSsrFlagHighLevelDepA.t | 84 ++ kaitai/python/kaitai_sbp/integrity.py | 33 +- kaitai/python/kaitai_sbp/sbp.py | 9 +- kaitai/python/kaitai_sbp/table.py | 3 +- ...check_sbp_integrity_MsgSsrFlagHighLevel.py | 14 +- ...k_sbp_integrity_MsgSsrFlagHighLevelDepA.py | 69 ++ proto/integrity.proto | 27 +- python/sbp/integrity.py | 187 +++- python/tests/sbp/test_table.py | 148 +-- rust/sbp/src/messages/integrity.rs | 674 +++++++++++- rust/sbp/src/messages/mod.rs | 29 + ...k_sbp_integrity_msg_ssr_flag_high_level.rs | 94 +- ...integrity_msg_ssr_flag_high_level_dep_a.rs | 484 +++++++++ rust/sbp/tests/integration/main.rs | 1 + sbpjson/elm/SbpJson.elm | 13 +- sbpjson/typescript/SbpJson.ts | 6 +- .../integrity/test_MsgSsrFlagHighLevel.yaml | 89 +- .../test_MsgSsrFlagHighLevelDepA.yaml | 46 + 52 files changed, 4885 insertions(+), 315 deletions(-) create mode 100644 c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL_DEP_A.h create mode 100644 c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.c create mode 100644 c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.cc create mode 100644 java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevelDepA.java create mode 100644 java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.java create mode 100644 kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.t create mode 100644 kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.py create mode 100644 rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs create mode 100644 spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml diff --git a/README.md b/README.md index 01a7a7f9e..882cf2e53 100644 --- a/README.md +++ b/README.md @@ -1,24 +1,24 @@ -## Specification and Bindings for Swift Binary Protocol +# Specification and Bindings for Swift Binary Protocol - [Specification and Bindings for Swift Binary Protocol](#specification-and-bindings-for-swift-binary-protocol) -- [Installing sbp2json, json2sbp, json2json and related tools](#installing-sbp2json-json2sbp-json2json-and-related-tools) -- [Building / installing](#building--installing) - - [Using Docker](#using-docker) - - [Fetching the prebuilt image from DockerHub](#fetching-the-prebuilt-image-from-dockerhub) - - [Creating your own image](#creating-your-own-image) - - [Using the docker image](#using-the-docker-image) - - [Installing from package managers](#installing-from-package-managers) - - [Installing development Python versions](#installing-development-python-versions) - - [Adding development version as a pip dependency](#adding-development-version-as-a-pip-dependency) - - [Installing from source](#installing-from-source) -- [SBP Development Procedures](#sbp-development-procedures) -- [SBP Protocol Specification](#sbp-protocol-specification) -- [JSON Schema Definitions](#json-schema-definitions) -- [Kaitai Struct Format Descriptions](#kaitai-struct-format-descriptions) - - [Notes on python bindings](#notes-on-python-bindings) -- [LICENSE](#license) + - [Installing sbp2json, json2sbp, json2json and related tools](#installing-sbp2json-json2sbp-json2json-and-related-tools) + - [Building / installing](#building--installing) + - [Using Docker](#using-docker) + - [Fetching the prebuilt image from DockerHub](#fetching-the-prebuilt-image-from-dockerhub) + - [Creating your own image](#creating-your-own-image) + - [Using the docker image](#using-the-docker-image) + - [Installing from package managers](#installing-from-package-managers) + - [Installing development Python versions](#installing-development-python-versions) + - [Adding development version as a pip dependency](#adding-development-version-as-a-pip-dependency) + - [Installing from source](#installing-from-source) + - [SBP Development Procedures](#sbp-development-procedures) + - [SBP Protocol Specification](#sbp-protocol-specification) + - [JSON Schema Definitions](#json-schema-definitions) + - [Kaitai Struct Format Descriptions](#kaitai-struct-format-descriptions) + - [Notes on python bindings](#notes-on-python-bindings) + - [LICENSE](#license) @@ -129,7 +129,7 @@ docker run --rm -v $PWD:/mnt/workspace -i -t swiftnav/libsbp-build:2025-02-10 /b This will mount your local copy of the libsbp repository onto the image. -Check this [link](https://hub.docker.com/r/swiftnav/libsbp-build/tags) for newer tags. +Check libsbp-build [dockerhub page](https://hub.docker.com/r/swiftnav/libsbp-build/tags) for newer tags. Alternatively, you could run ```sh @@ -279,7 +279,7 @@ detection. Please see [the docs](docs/sbp.pdf) for a full description of the packet structure and the message types. Developer documentation for the -language-specific sbp libraries is [here](http://swift-nav.github.io/libsbp/). +language-specific sbp libraries is available at [http://swift-nav.github.io/libsbp/](http://swift-nav.github.io/libsbp/). Please refer to [the changelog](CHANGELOG.md) for more information about the evolution of the library and its messages. diff --git a/c/README.md b/c/README.md index 0a08a3571..3e047aefa 100644 --- a/c/README.md +++ b/c/README.md @@ -1,4 +1,4 @@ -## SBP Bindings for C +# SBP Bindings for C libsbp provides C bindings for Swift Binary Protocol (SBP), the native binary protocol used by the @@ -11,13 +11,13 @@ with no dependencies other than the standard C libraries. On Debian-based systems (including Ubuntu 12.10 or later) you can get dependencies with: -```shell +```sh sudo apt-get install build-essential pkg-config cmake doxygen check clang-format-6.0 ``` On Mac: -```shell +```sh brew tap swift-nav/swift-devs brew install check cmake pkg-config doxygen clang-tools-6.0 ``` diff --git a/c/include/libsbp/cpp/message_traits.h b/c/include/libsbp/cpp/message_traits.h index 85a3d2d97..7dbfc9f9c 100644 --- a/c/include/libsbp/cpp/message_traits.h +++ b/c/include/libsbp/cpp/message_traits.h @@ -6438,6 +6438,44 @@ struct MessageTraits { } }; +template <> +struct MessageTraits { + static constexpr sbp_msg_type_t id = SbpMsgSsrFlagHighLevelDepA; + static constexpr const char *name = "MSG_SSR_FLAG_HIGH_LEVEL_DEP_A"; + static const sbp_msg_ssr_flag_high_level_dep_a_t &get(const sbp_msg_t &msg) { + return msg.ssr_flag_high_level_dep_a; + } + static sbp_msg_ssr_flag_high_level_dep_a_t &get(sbp_msg_t &msg) { + return msg.ssr_flag_high_level_dep_a; + } + static void to_sbp_msg(const sbp_msg_ssr_flag_high_level_dep_a_t &msg, + sbp_msg_t *sbp_msg) { + sbp_msg->ssr_flag_high_level_dep_a = msg; + } + static sbp_msg_t to_sbp_msg(const sbp_msg_ssr_flag_high_level_dep_a_t &msg) { + sbp_msg_t sbp_msg; + sbp_msg.ssr_flag_high_level_dep_a = msg; + return sbp_msg; + } + static s8 send(sbp_state_t *state, u16 sender_id, + const sbp_msg_ssr_flag_high_level_dep_a_t &msg, + sbp_write_fn_t write) { + return sbp_msg_ssr_flag_high_level_dep_a_send(state, sender_id, &msg, + write); + } + static s8 encode(uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_high_level_dep_a_t &msg) { + return sbp_msg_ssr_flag_high_level_dep_a_encode(buf, len, n_written, &msg); + } + static s8 decode(const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_high_level_dep_a_t *msg) { + return sbp_msg_ssr_flag_high_level_dep_a_decode(buf, len, n_read, msg); + } + static size_t encoded_len(const sbp_msg_ssr_flag_high_level_dep_a_t &msg) { + return sbp_msg_ssr_flag_high_level_dep_a_encoded_len(&msg); + } +}; + template <> struct MessageTraits { static constexpr sbp_msg_type_t id = SbpMsgSsrFlagHighLevel; diff --git a/c/include/libsbp/integrity.h b/c/include/libsbp/integrity.h index 2d2ff792e..8ab8a8be9 100644 --- a/c/include/libsbp/integrity.h +++ b/c/include/libsbp/integrity.h @@ -20,6 +20,7 @@ #include #include #include +#include #include #include #include diff --git a/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h b/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h index a11c0aeff..254d1ba2e 100644 --- a/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h +++ b/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h @@ -72,9 +72,14 @@ typedef struct { sbp_gps_time_sec_t obs_time; /** - * GNSS reference time of the correction associated to the flag. + * GNSS reference time of the atmospheric correction associated to the flag. */ - sbp_gps_time_sec_t corr_time; + sbp_gps_time_sec_t atmo_corr_time; + + /** + * GNSS reference time of the satellite correction associated to the flag. + */ + sbp_gps_time_sec_t sat_corr_time; /** * SSR Solution ID. diff --git a/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL_DEP_A.h b/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL_DEP_A.h new file mode 100644 index 000000000..455fd31f8 --- /dev/null +++ b/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL_DEP_A.h @@ -0,0 +1,254 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +/***************************************************************************** + * Automatically generated from yaml/swiftnav/sbp/integrity.yaml + * with generate.py. Please do not hand edit! + *****************************************************************************/ + +#ifndef LIBSBP_INTEGRITY_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_H +#define LIBSBP_INTEGRITY_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_H + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/****************************************************************************** + * + * SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A + * + *****************************************************************************/ +/** Deprecated + * + * Deprecated. + */ +typedef struct { + /** + * GNSS reference time of the observation used to generate the flag. + */ + sbp_gps_time_sec_t obs_time; + + /** + * GNSS reference time of the correction associated to the flag. + */ + sbp_gps_time_sec_t corr_time; + + /** + * SSR Solution ID. + */ + u8 ssr_sol_id; + + /** + * Unique identifier of the set this tile belongs to. + */ + u16 tile_set_id; + + /** + * Unique identifier of this tile in the tile set. + */ + u16 tile_id; + + /** + * Chain and type of flag. + */ + u8 chain_id; + + /** + * Use GPS satellites. + */ + u8 use_gps_sat; + + /** + * Use GAL satellites. + */ + u8 use_gal_sat; + + /** + * Use BDS satellites. + */ + u8 use_bds_sat; + + /** + * Use QZSS satellites. + */ + u8 use_qzss_sat; + + /** + * Reserved + */ + u8 reserved[SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_RESERVED_MAX]; + + /** + * Use tropo grid points. + */ + u8 use_tropo_grid_points; + + /** + * Use iono grid points. + */ + u8 use_iono_grid_points; + + /** + * Use iono tile satellite LoS. + */ + u8 use_iono_tile_sat_los; + + /** + * Use iono grid point satellite LoS. + */ + u8 use_iono_grid_point_sat_los; +} sbp_msg_ssr_flag_high_level_dep_a_t; + +/** + * Get encoded size of an instance of sbp_msg_ssr_flag_high_level_dep_a_t + * + * @param msg sbp_msg_ssr_flag_high_level_dep_a_t instance + * @return Length of on-wire representation + */ +static inline size_t sbp_msg_ssr_flag_high_level_dep_a_encoded_len( + const sbp_msg_ssr_flag_high_level_dep_a_t *msg) { + (void)msg; + return SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_ENCODED_LEN; +} + +/** + * Encode an instance of sbp_msg_ssr_flag_high_level_dep_a_t to wire + * representation + * + * This function encodes the given instance in to the user provided buffer. The + * buffer provided to this function must be large enough to store the encoded + * message otherwise it will return SBP_ENCODE_ERROR without writing anything to + * the buffer. + * + * Specify the length of the destination buffer in the \p len parameter. If + * non-null the number of bytes written to the buffer will be returned in \p + * n_written. + * + * @param buf Destination buffer + * @param len Length of \p buf + * @param n_written If not null, on success will be set to the number of bytes + * written to \p buf + * @param msg Instance of sbp_msg_ssr_flag_high_level_dep_a_t to encode + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_high_level_dep_a_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_high_level_dep_a_t *msg); + +/** + * Decode an instance of sbp_msg_ssr_flag_high_level_dep_a_t from wire + * representation + * + * This function decodes the wire representation of a + * sbp_msg_ssr_flag_high_level_dep_a_t message to the given instance. The caller + * must specify the length of the buffer in the \p len parameter. If non-null + * the number of bytes read from the buffer will be returned in \p n_read. + * + * @param buf Wire representation of the sbp_msg_ssr_flag_high_level_dep_a_t + * instance + * @param len Length of \p buf + * @param n_read If not null, on success will be set to the number of bytes read + * from \p buf + * @param msg Destination + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_high_level_dep_a_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_high_level_dep_a_t *msg); +/** + * Send an instance of sbp_msg_ssr_flag_high_level_dep_a_t with the given write + * function + * + * An equivalent of #sbp_message_send which operates specifically on + * sbp_msg_ssr_flag_high_level_dep_a_t + * + * The given message will be encoded to wire representation and passed in to the + * given write function callback. The write callback will be called several + * times for each invocation of this function. + * + * @param s SBP state + * @param sender_id SBP sender id + * @param msg Message to send + * @param write Write function + * @return SBP_OK on success, or other libsbp error code + */ +SBP_EXPORT s8 sbp_msg_ssr_flag_high_level_dep_a_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_high_level_dep_a_t *msg, sbp_write_fn_t write); + +/** + * Compare two instances of sbp_msg_ssr_flag_high_level_dep_a_t + * + * The two instances will be compared and a value returned consistent with the + * return codes of comparison functions from the C standard library + * + * 0 will be returned if \p a and \p b are considered equal + * A value less than 0 will be returned if \p a is considered to be less than \p + * b A value greater than 0 will be returned if \p b is considered to be greater + * than \p b + * + * @param a sbp_msg_ssr_flag_high_level_dep_a_t instance + * @param b sbp_msg_ssr_flag_high_level_dep_a_t instance + * @return 0, <0, >0 + */ +SBP_EXPORT int sbp_msg_ssr_flag_high_level_dep_a_cmp( + const sbp_msg_ssr_flag_high_level_dep_a_t *a, + const sbp_msg_ssr_flag_high_level_dep_a_t *b); + +#ifdef __cplusplus +} + +static inline bool operator==(const sbp_msg_ssr_flag_high_level_dep_a_t &lhs, + const sbp_msg_ssr_flag_high_level_dep_a_t &rhs) { + return sbp_msg_ssr_flag_high_level_dep_a_cmp(&lhs, &rhs) == 0; +} + +static inline bool operator!=(const sbp_msg_ssr_flag_high_level_dep_a_t &lhs, + const sbp_msg_ssr_flag_high_level_dep_a_t &rhs) { + return sbp_msg_ssr_flag_high_level_dep_a_cmp(&lhs, &rhs) != 0; +} + +static inline bool operator<(const sbp_msg_ssr_flag_high_level_dep_a_t &lhs, + const sbp_msg_ssr_flag_high_level_dep_a_t &rhs) { + return sbp_msg_ssr_flag_high_level_dep_a_cmp(&lhs, &rhs) < 0; +} + +static inline bool operator<=(const sbp_msg_ssr_flag_high_level_dep_a_t &lhs, + const sbp_msg_ssr_flag_high_level_dep_a_t &rhs) { + return sbp_msg_ssr_flag_high_level_dep_a_cmp(&lhs, &rhs) <= 0; +} + +static inline bool operator>(const sbp_msg_ssr_flag_high_level_dep_a_t &lhs, + const sbp_msg_ssr_flag_high_level_dep_a_t &rhs) { + return sbp_msg_ssr_flag_high_level_dep_a_cmp(&lhs, &rhs) > 0; +} + +static inline bool operator>=(const sbp_msg_ssr_flag_high_level_dep_a_t &lhs, + const sbp_msg_ssr_flag_high_level_dep_a_t &rhs) { + return sbp_msg_ssr_flag_high_level_dep_a_cmp(&lhs, &rhs) >= 0; +} + +#endif // ifdef __cplusplus + +#endif /* LIBSBP_INTEGRITY_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_H */ diff --git a/c/include/libsbp/integrity_macros.h b/c/include/libsbp/integrity_macros.h index e565900f0..83f3df97f 100644 --- a/c/include/libsbp/integrity_macros.h +++ b/c/include/libsbp/integrity_macros.h @@ -23,6 +23,193 @@ */ #define SBP_INTEGRITY_SSR_HEADER_ENCODED_LEN 14u +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_SHIFT))) | \ + (((val) & (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GPS_SATELLITES_NOT_MONITORED (3) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_SHIFT))) | \ + (((val) & (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_GAL_SATELLITES_NOT_MONITORED (3) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_SHIFT))) | \ + (((val) & (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_BDS_SATELLITES_NOT_MONITORED (3) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_SHIFT))) | \ + (((val) & (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_QZSS_SATELLITES_NOT_MONITORED (3) +/** + * The maximum number of items that can be stored in + * sbp_msg_ssr_flag_high_level_dep_a_t::reserved before the maximum SBP message + * size is exceeded + */ +#define SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_RESERVED_MAX 5u + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_SHIFT))) | \ + (((val) & (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_TROPO_GRID_POINTS_NOT_MONITORED (3) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_SHIFT))) | \ + (((val) & (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINTS_NOT_MONITORED (3) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_MASK (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_SHIFT (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_GET(flags) \ + ((u8)( \ + (u8)((flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_SET(flags, \ + val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_SHIFT))) | \ + (((val) & \ + (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_NOMINAL (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_WARNING (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_ALERT (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_TILE_SATELLITE_LOS_NOT_MONITORED \ + (3) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_MASK \ + (0x7u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_SHIFT \ + (0u) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_SHIFT) & \ + SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_MASK)) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_MASK \ + << SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_SHIFT))) | \ + (((val) & \ + (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_MASK)) \ + << (SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_SHIFT))); \ + } while (0) + +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_NOMINAL \ + (0) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_WARNING \ + (1) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_ALERT \ + (2) +#define SBP_SSR_FLAG_HIGH_LEVEL_DEP_A_USE_IONO_GRID_POINT_SATELLITE_LOS_NOT_MONITORED \ + (3) +/** + * Encoded length of sbp_msg_ssr_flag_high_level_dep_a_t + */ +#define SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_ENCODED_LEN 31u + #define SBP_SSR_FLAG_HIGH_LEVEL_USE_GPS_SATELLITES_MASK (0x7u) #define SBP_SSR_FLAG_HIGH_LEVEL_USE_GPS_SATELLITES_SHIFT (0u) #define SBP_SSR_FLAG_HIGH_LEVEL_USE_GPS_SATELLITES_GET(flags) \ @@ -186,7 +373,7 @@ /** * Encoded length of sbp_msg_ssr_flag_high_level_t */ -#define SBP_MSG_SSR_FLAG_HIGH_LEVEL_ENCODED_LEN 31u +#define SBP_MSG_SSR_FLAG_HIGH_LEVEL_ENCODED_LEN 37u /** * The maximum number of items that can be stored in diff --git a/c/include/libsbp/sbp_msg.h b/c/include/libsbp/sbp_msg.h index 754aeb8e7..16b29dcf8 100644 --- a/c/include/libsbp/sbp_msg.h +++ b/c/include/libsbp/sbp_msg.h @@ -237,6 +237,7 @@ typedef union { sbp_msg_specan_t specan; sbp_msg_ssr_code_biases_t ssr_code_biases; sbp_msg_ssr_code_phase_biases_bounds_t ssr_code_phase_biases_bounds; + sbp_msg_ssr_flag_high_level_dep_a_t ssr_flag_high_level_dep_a; sbp_msg_ssr_flag_high_level_t ssr_flag_high_level; sbp_msg_ssr_flag_iono_grid_point_sat_los_t ssr_flag_iono_grid_point_sat_los; sbp_msg_ssr_flag_iono_grid_points_t ssr_flag_iono_grid_points; @@ -800,6 +801,9 @@ static inline s8 sbp_message_encode(uint8_t *buf, uint8_t len, case SbpMsgSsrCodePhaseBiasesBounds: return sbp_msg_ssr_code_phase_biases_bounds_encode( buf, len, n_written, &msg->ssr_code_phase_biases_bounds); + case SbpMsgSsrFlagHighLevelDepA: + return sbp_msg_ssr_flag_high_level_dep_a_encode( + buf, len, n_written, &msg->ssr_flag_high_level_dep_a); case SbpMsgSsrFlagHighLevel: return sbp_msg_ssr_flag_high_level_encode(buf, len, n_written, &msg->ssr_flag_high_level); @@ -1469,6 +1473,9 @@ static inline s8 sbp_message_decode(const uint8_t *buf, uint8_t len, case SbpMsgSsrCodePhaseBiasesBounds: return sbp_msg_ssr_code_phase_biases_bounds_decode( buf, len, n_read, &msg->ssr_code_phase_biases_bounds); + case SbpMsgSsrFlagHighLevelDepA: + return sbp_msg_ssr_flag_high_level_dep_a_decode( + buf, len, n_read, &msg->ssr_flag_high_level_dep_a); case SbpMsgSsrFlagHighLevel: return sbp_msg_ssr_flag_high_level_decode(buf, len, n_read, &msg->ssr_flag_high_level); @@ -2045,6 +2052,9 @@ static inline size_t sbp_message_encoded_len(sbp_msg_type_t msg_type, case SbpMsgSsrCodePhaseBiasesBounds: return sbp_msg_ssr_code_phase_biases_bounds_encoded_len( &msg->ssr_code_phase_biases_bounds); + case SbpMsgSsrFlagHighLevelDepA: + return sbp_msg_ssr_flag_high_level_dep_a_encoded_len( + &msg->ssr_flag_high_level_dep_a); case SbpMsgSsrFlagHighLevel: return sbp_msg_ssr_flag_high_level_encoded_len(&msg->ssr_flag_high_level); case SbpMsgSsrFlagIonoGridPointSatLos: @@ -2659,6 +2669,9 @@ static inline int sbp_message_cmp(sbp_msg_type_t msg_type, const sbp_msg_t *a, case SbpMsgSsrCodePhaseBiasesBounds: return sbp_msg_ssr_code_phase_biases_bounds_cmp( &a->ssr_code_phase_biases_bounds, &b->ssr_code_phase_biases_bounds); + case SbpMsgSsrFlagHighLevelDepA: + return sbp_msg_ssr_flag_high_level_dep_a_cmp( + &a->ssr_flag_high_level_dep_a, &b->ssr_flag_high_level_dep_a); case SbpMsgSsrFlagHighLevel: return sbp_msg_ssr_flag_high_level_cmp(&a->ssr_flag_high_level, &b->ssr_flag_high_level); diff --git a/c/include/libsbp/sbp_msg_type.h b/c/include/libsbp/sbp_msg_type.h index a098bfc01..7e6a7ffe6 100644 --- a/c/include/libsbp/sbp_msg_type.h +++ b/c/include/libsbp/sbp_msg_type.h @@ -228,7 +228,8 @@ typedef enum { SbpMsgSpecan = 0x0051, SbpMsgSsrCodeBiases = 0x05E1, SbpMsgSsrCodePhaseBiasesBounds = 0x05EC, - SbpMsgSsrFlagHighLevel = 0x0BB9, + SbpMsgSsrFlagHighLevelDepA = 0x0BB9, + SbpMsgSsrFlagHighLevel = 0x0BBA, SbpMsgSsrFlagIonoGridPointSatLos = 0x0BD1, SbpMsgSsrFlagIonoGridPoints = 0x0BC7, SbpMsgSsrFlagIonoTileSatLos = 0x0BCD, @@ -650,6 +651,8 @@ static inline const char *sbp_msg_type_to_string(sbp_msg_type_t msg_type) { return "MSG_SSR_CODE_BIASES"; case SbpMsgSsrCodePhaseBiasesBounds: return "MSG_SSR_CODE_PHASE_BIASES_BOUNDS"; + case SbpMsgSsrFlagHighLevelDepA: + return "MSG_SSR_FLAG_HIGH_LEVEL_DEP_A"; case SbpMsgSsrFlagHighLevel: return "MSG_SSR_FLAG_HIGH_LEVEL"; case SbpMsgSsrFlagIonoGridPointSatLos: diff --git a/c/src/include/libsbp/internal/integrity.h b/c/src/include/libsbp/internal/integrity.h index 470067bd0..c1f4c01cf 100644 --- a/c/src/include/libsbp/internal/integrity.h +++ b/c/src/include/libsbp/internal/integrity.h @@ -48,6 +48,26 @@ bool sbp_integrity_ssr_header_encode_internal( bool sbp_integrity_ssr_header_decode_internal(sbp_decode_ctx_t *ctx, sbp_integrity_ssr_header_t *msg); +/** + * Internal function to encode an SBP type to a buffer + * + * @param ctx Encode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_high_level_dep_a_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_high_level_dep_a_t *msg); + +/** + * Internal function to decode an SBP type from a buffer + * + * @param ctx Decode context + * @param msg SBP type instance + * @return true on success, false otherwise + */ +bool sbp_msg_ssr_flag_high_level_dep_a_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_high_level_dep_a_t *msg); + /** * Internal function to encode an SBP type to a buffer * diff --git a/c/src/integrity.c b/c/src/integrity.c index 290ee862d..d873596fa 100644 --- a/c/src/integrity.c +++ b/c/src/integrity.c @@ -139,12 +139,250 @@ int sbp_integrity_ssr_header_cmp(const sbp_integrity_ssr_header_t *a, return ret; } +bool sbp_msg_ssr_flag_high_level_dep_a_encode_internal( + sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_high_level_dep_a_t *msg) { + if (!sbp_gps_time_sec_encode_internal(ctx, &msg->obs_time)) { + return false; + } + if (!sbp_gps_time_sec_encode_internal(ctx, &msg->corr_time)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->ssr_sol_id)) { + return false; + } + if (!sbp_u16_encode(ctx, &msg->tile_set_id)) { + return false; + } + if (!sbp_u16_encode(ctx, &msg->tile_id)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->chain_id)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_gps_sat)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_gal_sat)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_bds_sat)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_qzss_sat)) { + return false; + } + for (size_t i = 0; i < SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_RESERVED_MAX; i++) { + if (!sbp_u8_encode(ctx, &msg->reserved[i])) { + return false; + } + } + if (!sbp_u8_encode(ctx, &msg->use_tropo_grid_points)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_iono_grid_points)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_iono_tile_sat_los)) { + return false; + } + if (!sbp_u8_encode(ctx, &msg->use_iono_grid_point_sat_los)) { + return false; + } + return true; +} + +s8 sbp_msg_ssr_flag_high_level_dep_a_encode( + uint8_t *buf, uint8_t len, uint8_t *n_written, + const sbp_msg_ssr_flag_high_level_dep_a_t *msg) { + sbp_encode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_high_level_dep_a_encode_internal(&ctx, msg)) { + return SBP_ENCODE_ERROR; + } + if (n_written != NULL) { + *n_written = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +bool sbp_msg_ssr_flag_high_level_dep_a_decode_internal( + sbp_decode_ctx_t *ctx, sbp_msg_ssr_flag_high_level_dep_a_t *msg) { + if (!sbp_gps_time_sec_decode_internal(ctx, &msg->obs_time)) { + return false; + } + if (!sbp_gps_time_sec_decode_internal(ctx, &msg->corr_time)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->ssr_sol_id)) { + return false; + } + if (!sbp_u16_decode(ctx, &msg->tile_set_id)) { + return false; + } + if (!sbp_u16_decode(ctx, &msg->tile_id)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->chain_id)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_gps_sat)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_gal_sat)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_bds_sat)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_qzss_sat)) { + return false; + } + for (uint8_t i = 0; i < SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_RESERVED_MAX; i++) { + if (!sbp_u8_decode(ctx, &msg->reserved[i])) { + return false; + } + } + if (!sbp_u8_decode(ctx, &msg->use_tropo_grid_points)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_iono_grid_points)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_iono_tile_sat_los)) { + return false; + } + if (!sbp_u8_decode(ctx, &msg->use_iono_grid_point_sat_los)) { + return false; + } + return true; +} + +s8 sbp_msg_ssr_flag_high_level_dep_a_decode( + const uint8_t *buf, uint8_t len, uint8_t *n_read, + sbp_msg_ssr_flag_high_level_dep_a_t *msg) { + sbp_decode_ctx_t ctx; + ctx.buf = buf; + ctx.buf_len = len; + ctx.offset = 0; + if (!sbp_msg_ssr_flag_high_level_dep_a_decode_internal(&ctx, msg)) { + return SBP_DECODE_ERROR; + } + if (n_read != NULL) { + *n_read = (uint8_t)ctx.offset; + } + return SBP_OK; +} + +s8 sbp_msg_ssr_flag_high_level_dep_a_send( + sbp_state_t *s, u16 sender_id, + const sbp_msg_ssr_flag_high_level_dep_a_t *msg, sbp_write_fn_t write) { + uint8_t payload[SBP_MAX_PAYLOAD_LEN]; + uint8_t payload_len; + s8 ret = sbp_msg_ssr_flag_high_level_dep_a_encode(payload, sizeof(payload), + &payload_len, msg); + if (ret != SBP_OK) { + return ret; + } + return sbp_internal_forward_payload(s, SbpMsgSsrFlagHighLevelDepA, sender_id, + payload_len, payload, write); +} + +int sbp_msg_ssr_flag_high_level_dep_a_cmp( + const sbp_msg_ssr_flag_high_level_dep_a_t *a, + const sbp_msg_ssr_flag_high_level_dep_a_t *b) { + int ret = 0; + + ret = sbp_gps_time_sec_cmp(&a->obs_time, &b->obs_time); + if (ret != 0) { + return ret; + } + + ret = sbp_gps_time_sec_cmp(&a->corr_time, &b->corr_time); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->ssr_sol_id, &b->ssr_sol_id); + if (ret != 0) { + return ret; + } + + ret = sbp_u16_cmp(&a->tile_set_id, &b->tile_set_id); + if (ret != 0) { + return ret; + } + + ret = sbp_u16_cmp(&a->tile_id, &b->tile_id); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->chain_id, &b->chain_id); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_gps_sat, &b->use_gps_sat); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_gal_sat, &b->use_gal_sat); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_bds_sat, &b->use_bds_sat); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_qzss_sat, &b->use_qzss_sat); + if (ret != 0) { + return ret; + } + + for (uint8_t i = 0; i < SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A_RESERVED_MAX; i++) { + ret = sbp_u8_cmp(&a->reserved[i], &b->reserved[i]); + if (ret != 0) { + return ret; + } + } + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_tropo_grid_points, &b->use_tropo_grid_points); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_iono_grid_points, &b->use_iono_grid_points); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_iono_tile_sat_los, &b->use_iono_tile_sat_los); + if (ret != 0) { + return ret; + } + + ret = sbp_u8_cmp(&a->use_iono_grid_point_sat_los, + &b->use_iono_grid_point_sat_los); + return ret; +} + bool sbp_msg_ssr_flag_high_level_encode_internal( sbp_encode_ctx_t *ctx, const sbp_msg_ssr_flag_high_level_t *msg) { if (!sbp_gps_time_sec_encode_internal(ctx, &msg->obs_time)) { return false; } - if (!sbp_gps_time_sec_encode_internal(ctx, &msg->corr_time)) { + if (!sbp_gps_time_sec_encode_internal(ctx, &msg->atmo_corr_time)) { + return false; + } + if (!sbp_gps_time_sec_encode_internal(ctx, &msg->sat_corr_time)) { return false; } if (!sbp_u8_encode(ctx, &msg->ssr_sol_id)) { @@ -212,7 +450,10 @@ bool sbp_msg_ssr_flag_high_level_decode_internal( if (!sbp_gps_time_sec_decode_internal(ctx, &msg->obs_time)) { return false; } - if (!sbp_gps_time_sec_decode_internal(ctx, &msg->corr_time)) { + if (!sbp_gps_time_sec_decode_internal(ctx, &msg->atmo_corr_time)) { + return false; + } + if (!sbp_gps_time_sec_decode_internal(ctx, &msg->sat_corr_time)) { return false; } if (!sbp_u8_decode(ctx, &msg->ssr_sol_id)) { @@ -298,7 +539,12 @@ int sbp_msg_ssr_flag_high_level_cmp(const sbp_msg_ssr_flag_high_level_t *a, return ret; } - ret = sbp_gps_time_sec_cmp(&a->corr_time, &b->corr_time); + ret = sbp_gps_time_sec_cmp(&a->atmo_corr_time, &b->atmo_corr_time); + if (ret != 0) { + return ret; + } + + ret = sbp_gps_time_sec_cmp(&a->sat_corr_time, &b->sat_corr_time); if (ret != 0) { return ret; } diff --git a/c/src/sbp.c b/c/src/sbp.c index fdbf029d2..25934c286 100644 --- a/c/src/sbp.c +++ b/c/src/sbp.c @@ -162,7 +162,7 @@ * registered for that message type. */ static s8 sbp_register_callback_generic(sbp_state_t *s, sbp_msg_type_t msg_type, - sbp_callback_t cb, + sbp_callback_t cb, void *context, sbp_msg_callbacks_node_t *node) { /* Check our callback function pointer isn't NULL. */ @@ -505,7 +505,7 @@ s8 sbp_process(sbp_state_t *s, s32 (*read)(u8 *buff, u32 n, void *context)) ret = process_frame(s, s->sender_id, s->msg_type, s->msg_len, SBP_FRAME_MSG_PAYLOAD(s->frame_buff)); return ret; - } + } return SBP_CRC_ERROR; } break; diff --git a/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c index 68ec2a2e6..25242e200 100644 --- a/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c +++ b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c @@ -90,13 +90,13 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { logging_reset(); - sbp_callback_register(&sbp_state, 3001, &msg_callback, + sbp_callback_register(&sbp_state, 3002, &msg_callback, &DUMMY_MEMORY_FOR_CALLBACKS, &n); u8 encoded_frame[] = { - 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, - 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, 1, 2, - 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + 85, 186, 11, 66, 0, 37, 180, 0, 0, 0, 3, 0, 109, 1, 0, + 0, 6, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, + 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 177, 238, }; dummy_reset(); @@ -104,11 +104,11 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { sbp_msg_t test_msg; memset(&test_msg, 0, sizeof(test_msg)); - test_msg.ssr_flag_high_level.chain_id = 40; + test_msg.ssr_flag_high_level.atmo_corr_time.tow = 365; - test_msg.ssr_flag_high_level.corr_time.tow = 360; + test_msg.ssr_flag_high_level.atmo_corr_time.wn = 6; - test_msg.ssr_flag_high_level.corr_time.wn = 6; + test_msg.ssr_flag_high_level.chain_id = 40; test_msg.ssr_flag_high_level.obs_time.tow = 180; @@ -124,6 +124,10 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { test_msg.ssr_flag_high_level.reserved[4] = 0; + test_msg.ssr_flag_high_level.sat_corr_time.tow = 360; + + test_msg.ssr_flag_high_level.sat_corr_time.wn = 6; + test_msg.ssr_flag_high_level.ssr_sol_id = 10; test_msg.ssr_flag_high_level.tile_id = 30; @@ -170,24 +174,24 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { sbp_message_cmp(SbpMsgSsrFlagHighLevel, &last_msg.msg, &test_msg) == 0, "Sent and received messages did not compare equal"); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.atmo_corr_time.tow == 365, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.atmo_corr_time.tow, " + "expected 365, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level.atmo_corr_time.tow); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level.atmo_corr_time.wn == 6, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.atmo_corr_time.wn, " + "expected 6, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level.atmo_corr_time.wn); + ck_assert_msg( last_msg.msg.ssr_flag_high_level.chain_id == 40, "incorrect value for last_msg.msg.ssr_flag_high_level.chain_id, " "expected 40, is %" PRId64, (int64_t)last_msg.msg.ssr_flag_high_level.chain_id); - ck_assert_msg( - last_msg.msg.ssr_flag_high_level.corr_time.tow == 360, - "incorrect value for last_msg.msg.ssr_flag_high_level.corr_time.tow, " - "expected 360, is %" PRId64, - (int64_t)last_msg.msg.ssr_flag_high_level.corr_time.tow); - - ck_assert_msg( - last_msg.msg.ssr_flag_high_level.corr_time.wn == 6, - "incorrect value for last_msg.msg.ssr_flag_high_level.corr_time.wn, " - "expected 6, is %" PRId64, - (int64_t)last_msg.msg.ssr_flag_high_level.corr_time.wn); - ck_assert_msg( last_msg.msg.ssr_flag_high_level.obs_time.tow == 180, "incorrect value for last_msg.msg.ssr_flag_high_level.obs_time.tow, " @@ -226,6 +230,18 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { "expected 0, is %" PRId64, (int64_t)last_msg.msg.ssr_flag_high_level.reserved[4]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.sat_corr_time.tow == 360, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.sat_corr_time.tow, " + "expected 360, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level.sat_corr_time.tow); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level.sat_corr_time.wn == 6, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level.sat_corr_time.wn, expected " + "6, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level.sat_corr_time.wn); + ck_assert_msg( last_msg.msg.ssr_flag_high_level.ssr_sol_id == 10, "incorrect value for last_msg.msg.ssr_flag_high_level.ssr_sol_id, " diff --git a/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.c b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.c new file mode 100644 index 000000000..6c1700580 --- /dev/null +++ b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.c @@ -0,0 +1,313 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include // for debugging +#include // for malloc + +static struct { + u32 n_callbacks_logged; + u16 sender_id; + sbp_msg_type_t msg_type; + sbp_msg_t msg; + void *context; +} last_msg; + +static size_t dummy_wr = 0; +static size_t dummy_rd = 0; +static u8 dummy_buff[1024]; +static void *last_io_context; + +static void *DUMMY_MEMORY_FOR_CALLBACKS = (void *)0xdeadbeef; +static void *DUMMY_MEMORY_FOR_IO = (void *)0xdead0000; + +static void dummy_reset() { + dummy_rd = dummy_wr = 0; + memset(dummy_buff, 0, sizeof(dummy_buff)); +} + +static s32 dummy_write(u8 *buff, u32 n, void *context) { + last_io_context = context; + size_t real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(dummy_buff + dummy_wr, buff, real_n); + dummy_wr += real_n; + return (s32)real_n; +} + +static s32 dummy_read(u8 *buff, u32 n, void *context) { + last_io_context = context; + size_t real_n = n; //(dummy_n > n) ? n : dummy_n; + memcpy(buff, dummy_buff + dummy_rd, real_n); + dummy_rd += real_n; + return (s32)real_n; +} + +static void logging_reset() { memset(&last_msg, 0, sizeof(last_msg)); } + +static void msg_callback(u16 sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *context) { + last_msg.n_callbacks_logged++; + last_msg.sender_id = sender_id; + last_msg.msg_type = msg_type; + last_msg.msg = *msg; + last_msg.context = context; +} + +START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA) { + static sbp_msg_callbacks_node_t n; + + // State of the SBP message parser. + // Must be statically allocated. + sbp_state_t sbp_state; + + // + // Run tests: + // + // Test successful parsing of a message + { + // SBP parser state must be initialized before sbp_process is called. + // We re-initialize before every test so that callbacks for the same message + // types can be + // allocated multiple times across different tests. + sbp_state_init(&sbp_state); + + sbp_state_set_io_context(&sbp_state, &DUMMY_MEMORY_FOR_IO); + + logging_reset(); + + sbp_callback_register(&sbp_state, 3001, &msg_callback, + &DUMMY_MEMORY_FOR_CALLBACKS, &n); + + u8 encoded_frame[] = { + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, + 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, 1, 2, + 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + }; + + dummy_reset(); + + sbp_msg_t test_msg; + memset(&test_msg, 0, sizeof(test_msg)); + + test_msg.ssr_flag_high_level_dep_a.chain_id = 40; + + test_msg.ssr_flag_high_level_dep_a.corr_time.tow = 360; + + test_msg.ssr_flag_high_level_dep_a.corr_time.wn = 6; + + test_msg.ssr_flag_high_level_dep_a.obs_time.tow = 180; + + test_msg.ssr_flag_high_level_dep_a.obs_time.wn = 3; + + test_msg.ssr_flag_high_level_dep_a.reserved[0] = 0; + + test_msg.ssr_flag_high_level_dep_a.reserved[1] = 0; + + test_msg.ssr_flag_high_level_dep_a.reserved[2] = 0; + + test_msg.ssr_flag_high_level_dep_a.reserved[3] = 0; + + test_msg.ssr_flag_high_level_dep_a.reserved[4] = 0; + + test_msg.ssr_flag_high_level_dep_a.ssr_sol_id = 10; + + test_msg.ssr_flag_high_level_dep_a.tile_id = 30; + + test_msg.ssr_flag_high_level_dep_a.tile_set_id = 20; + + test_msg.ssr_flag_high_level_dep_a.use_bds_sat = 3; + + test_msg.ssr_flag_high_level_dep_a.use_gal_sat = 2; + + test_msg.ssr_flag_high_level_dep_a.use_gps_sat = 1; + + test_msg.ssr_flag_high_level_dep_a.use_iono_grid_point_sat_los = 8; + + test_msg.ssr_flag_high_level_dep_a.use_iono_grid_points = 6; + + test_msg.ssr_flag_high_level_dep_a.use_iono_tile_sat_los = 7; + + test_msg.ssr_flag_high_level_dep_a.use_qzss_sat = 4; + + test_msg.ssr_flag_high_level_dep_a.use_tropo_grid_points = 5; + + sbp_message_send(&sbp_state, SbpMsgSsrFlagHighLevelDepA, 66, &test_msg, + &dummy_write); + + ck_assert_msg(dummy_wr == sizeof(encoded_frame), + "not enough data was written to dummy_buff (expected: %zu, " + "actual: %zu)", + sizeof(encoded_frame), dummy_wr); + ck_assert_msg(memcmp(dummy_buff, encoded_frame, sizeof(encoded_frame)) == 0, + "frame was not encoded properly"); + + while (dummy_rd < dummy_wr) { + ck_assert_msg(sbp_process(&sbp_state, &dummy_read) >= SBP_OK, + "sbp_process threw an error!"); + } + + ck_assert_msg(last_msg.n_callbacks_logged == 1, + "msg_callback: one callback should have been logged"); + ck_assert_msg(last_msg.sender_id == 66, + "msg_callback: sender_id decoded incorrectly"); + + ck_assert_msg(sbp_message_cmp(SbpMsgSsrFlagHighLevelDepA, &last_msg.msg, + &test_msg) == 0, + "Sent and received messages did not compare equal"); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.chain_id == 40, + "incorrect value for last_msg.msg.ssr_flag_high_level_dep_a.chain_id, " + "expected 40, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.chain_id); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.corr_time.tow == 360, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.corr_time.tow, expected 360, " + "is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.corr_time.tow); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.corr_time.wn == 6, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.corr_time.wn, " + "expected 6, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.corr_time.wn); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.obs_time.tow == 180, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.obs_time.tow, " + "expected 180, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.obs_time.tow); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.obs_time.wn == 3, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.obs_time.wn, " + "expected 3, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.obs_time.wn); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.reserved[0] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.reserved[0], " + "expected 0, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.reserved[0]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.reserved[1] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.reserved[1], " + "expected 0, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.reserved[1]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.reserved[2] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.reserved[2], " + "expected 0, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.reserved[2]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.reserved[3] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.reserved[3], " + "expected 0, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.reserved[3]); + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.reserved[4] == 0, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.reserved[4], " + "expected 0, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.reserved[4]); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.ssr_sol_id == 10, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.ssr_sol_id, expected " + "10, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.ssr_sol_id); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.tile_id == 30, + "incorrect value for last_msg.msg.ssr_flag_high_level_dep_a.tile_id, " + "expected 30, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.tile_id); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.tile_set_id == 20, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.tile_set_id, " + "expected 20, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.tile_set_id); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.use_bds_sat == 3, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_bds_sat, " + "expected 3, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_bds_sat); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.use_gal_sat == 2, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_gal_sat, " + "expected 2, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_gal_sat); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.use_gps_sat == 1, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_gps_sat, " + "expected 1, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_gps_sat); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.use_iono_grid_point_sat_los == 8, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_iono_grid_point_sat_los, " + "expected 8, is %" PRId64, + (int64_t) + last_msg.msg.ssr_flag_high_level_dep_a.use_iono_grid_point_sat_los); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.use_iono_grid_points == 6, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_iono_grid_points, expected " + "6, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_iono_grid_points); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.use_iono_tile_sat_los == 7, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_iono_tile_sat_los, " + "expected 7, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_iono_tile_sat_los); + + ck_assert_msg(last_msg.msg.ssr_flag_high_level_dep_a.use_qzss_sat == 4, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_qzss_sat, " + "expected 4, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_qzss_sat); + + ck_assert_msg( + last_msg.msg.ssr_flag_high_level_dep_a.use_tropo_grid_points == 5, + "incorrect value for " + "last_msg.msg.ssr_flag_high_level_dep_a.use_tropo_grid_points, " + "expected 5, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level_dep_a.use_tropo_grid_points); + } +} +END_TEST + +Suite *auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA_suite(void) { + Suite *s = suite_create( + "SBP generated test suite: " + "auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA"); + TCase *tc_acq = tcase_create( + "Automated_Suite_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA"); + tcase_add_test(tc_acq, test_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA); + suite_add_tcase(s, tc_acq); + return s; +} diff --git a/c/test/check_main.c b/c/test/check_main.c index 02127b32c..a714e2bce 100644 --- a/c/test/check_main.c +++ b/c/test/check_main.c @@ -63,6 +63,8 @@ int main(void) { srunner_add_suite(sr, auto_check_sbp_imu_MsgImuRaw_suite()); srunner_add_suite(sr, auto_check_sbp_integrity_MsgAcknowledge_suite()); srunner_add_suite(sr, auto_check_sbp_integrity_MsgSsrFlagHighLevel_suite()); + srunner_add_suite(sr, + auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA_suite()); srunner_add_suite( sr, auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos_suite()); srunner_add_suite(sr, diff --git a/c/test/check_suites.h b/c/test/check_suites.h index 47b58ebc1..887bab1cf 100644 --- a/c/test/check_suites.h +++ b/c/test/check_suites.h @@ -53,6 +53,7 @@ Suite* auto_check_sbp_imu_MsgImuComp_suite(void); Suite* auto_check_sbp_imu_MsgImuRaw_suite(void); Suite* auto_check_sbp_integrity_MsgAcknowledge_suite(void); Suite* auto_check_sbp_integrity_MsgSsrFlagHighLevel_suite(void); +Suite* auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA_suite(void); Suite* auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLos_suite(void); Suite* auto_check_sbp_integrity_MsgSsrFlagIonoGridPoints_suite(void); Suite* auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLos_suite(void); diff --git a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc index 0c7bc59ff..46013567b 100644 --- a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc +++ b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc @@ -30,9 +30,9 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 : public ::testing::Test { public: Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0() { + assign(test_msg_.atmo_corr_time.tow, 365); + assign(test_msg_.atmo_corr_time.wn, 6); assign(test_msg_.chain_id, 40); - assign(test_msg_.corr_time.tow, 360); - assign(test_msg_.corr_time.wn, 6); assign(test_msg_.obs_time.tow, 180); assign(test_msg_.obs_time.wn, 3); @@ -45,6 +45,8 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 assign(test_msg_.reserved[3], 0); assign(test_msg_.reserved[4], 0); + assign(test_msg_.sat_corr_time.tow, 360); + assign(test_msg_.sat_corr_time.wn, 6); assign(test_msg_.ssr_sol_id, 10); assign(test_msg_.tile_id, 30); assign(test_msg_.tile_set_id, 20); @@ -297,11 +299,11 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 info.msg_type = static_cast(SbpMsgSsrFlagHighLevel); info.sender_id = 66; info.preamble = 0x55; - info.crc = 0x0369; + info.crc = 0xEEB1; info.encoded_frame = encoded_frame_; info.frame_len = sizeof(encoded_frame_); info.encoded_payload = encoded_payload_; - info.payload_len = 31; + info.payload_len = 37; return info; } @@ -401,13 +403,14 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 private: sbp_msg_ssr_flag_high_level_t test_msg_{}; - uint8_t encoded_frame_[31 + 8] = { - 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, - 0, 30, 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + uint8_t encoded_frame_[37 + 8] = { + 85, 186, 11, 66, 0, 37, 180, 0, 0, 0, 3, 0, 109, 1, 0, + 0, 6, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, + 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 177, 238, }; - uint8_t encoded_payload_[31] = { - 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, - 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, + uint8_t encoded_payload_[37] = { + 180, 0, 0, 0, 3, 0, 109, 1, 0, 0, 6, 0, 104, 1, 0, 0, 6, 0, 10, + 20, 0, 30, 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, }; }; @@ -423,39 +426,39 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, EncodedLen) { TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, EncodeToBuf) { auto info = get_test_msg_info(); - uint8_t buf[31]; + uint8_t buf[37]; uint8_t n_written; EXPECT_EQ(sbp_msg_ssr_flag_high_level_encode(&buf[0], sizeof(buf), &n_written, &info.test_msg), SBP_OK); - EXPECT_EQ(n_written, 31); - EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); + EXPECT_EQ(n_written, 37); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 37), 0); memset(&buf[0], 0, sizeof(buf)); EXPECT_EQ(sbp_message_encode(&buf[0], sizeof(buf), &n_written, SbpMsgSsrFlagHighLevel, &info.test_msg_wrapped), SBP_OK); - EXPECT_EQ(n_written, 31); - EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); + EXPECT_EQ(n_written, 37); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 37), 0); } TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, EncodeToBufWithoutNwritten) { auto info = get_test_msg_info(); - uint8_t buf[31]; + uint8_t buf[37]; EXPECT_EQ(sbp_msg_ssr_flag_high_level_encode(&buf[0], sizeof(buf), nullptr, &info.test_msg), SBP_OK); - EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 37), 0); } TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, EncodedToBufUnderflow) { auto info = get_test_msg_info(); - uint8_t buf[31]; + uint8_t buf[37]; - for (uint8_t i = 0; i < 31; i++) { + for (uint8_t i = 0; i < 37; i++) { EXPECT_EQ( sbp_msg_ssr_flag_high_level_encode(&buf[0], i, nullptr, &info.test_msg), SBP_ENCODE_ERROR); @@ -470,14 +473,14 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, DecodeFromBuf) { EXPECT_EQ(sbp_msg_ssr_flag_high_level_decode(&info.encoded_payload[0], info.payload_len, &n_read, &msg), SBP_OK); - EXPECT_EQ(n_read, 31); + EXPECT_EQ(n_read, 37); EXPECT_EQ(msg, info.test_msg); sbp_msg_t wrapped_msg{}; EXPECT_EQ(sbp_message_decode(&info.encoded_payload[0], info.payload_len, &n_read, SbpMsgSsrFlagHighLevel, &wrapped_msg), SBP_OK); - EXPECT_EQ(n_read, 31); + EXPECT_EQ(n_read, 37); EXPECT_EQ(msg, info.test_msg); } @@ -663,19 +666,19 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, Comparison) { { sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; sbp_msg_ssr_flag_high_level_t greater = info.test_msg; - make_lesser_greater(lesser.chain_id, greater.chain_id); + make_lesser_greater(lesser.atmo_corr_time.tow, greater.atmo_corr_time.tow); comparison_tests(lesser, greater); } { sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; sbp_msg_ssr_flag_high_level_t greater = info.test_msg; - make_lesser_greater(lesser.corr_time.tow, greater.corr_time.tow); + make_lesser_greater(lesser.atmo_corr_time.wn, greater.atmo_corr_time.wn); comparison_tests(lesser, greater); } { sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; sbp_msg_ssr_flag_high_level_t greater = info.test_msg; - make_lesser_greater(lesser.corr_time.wn, greater.corr_time.wn); + make_lesser_greater(lesser.chain_id, greater.chain_id); comparison_tests(lesser, greater); } { @@ -725,6 +728,18 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, Comparison) { make_lesser_greater(lesser.reserved[4], greater.reserved[4]); comparison_tests(lesser, greater); } + { + sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_t greater = info.test_msg; + make_lesser_greater(lesser.sat_corr_time.tow, greater.sat_corr_time.tow); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_t greater = info.test_msg; + make_lesser_greater(lesser.sat_corr_time.wn, greater.sat_corr_time.wn); + comparison_tests(lesser, greater); + } { sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; sbp_msg_ssr_flag_high_level_t greater = info.test_msg; @@ -861,14 +876,14 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, CppTraitsEncodeToBuf) { auto info = get_test_msg_info(); - uint8_t buf[31]; + uint8_t buf[37]; uint8_t n_written; EXPECT_EQ(sbp::MessageTraits::encode( &buf[0], sizeof(buf), &n_written, info.test_msg), SBP_OK); - EXPECT_EQ(n_written, 31); - EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); + EXPECT_EQ(n_written, 37); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 37), 0); } TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, @@ -880,7 +895,7 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, EXPECT_EQ(sbp::MessageTraits::decode( &info.encoded_payload[0], info.payload_len, &n_read, &msg), SBP_OK); - EXPECT_EQ(n_read, 31); + EXPECT_EQ(n_read, 37); EXPECT_EQ(msg, info.test_msg); } diff --git a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.cc b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.cc new file mode 100644 index 000000000..46103eae0 --- /dev/null +++ b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.cc @@ -0,0 +1,962 @@ +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml by +// generate.py. Do not modify by hand! + +#include +#include +#include +#include +#include + +namespace { + +template +void assign(T &dest, const U &source) { + dest = static_cast(source); +} +class Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0 + : public ::testing::Test { + public: + Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0() { + assign(test_msg_.chain_id, 40); + assign(test_msg_.corr_time.tow, 360); + assign(test_msg_.corr_time.wn, 6); + assign(test_msg_.obs_time.tow, 180); + assign(test_msg_.obs_time.wn, 3); + + assign(test_msg_.reserved[0], 0); + + assign(test_msg_.reserved[1], 0); + + assign(test_msg_.reserved[2], 0); + + assign(test_msg_.reserved[3], 0); + + assign(test_msg_.reserved[4], 0); + assign(test_msg_.ssr_sol_id, 10); + assign(test_msg_.tile_id, 30); + assign(test_msg_.tile_set_id, 20); + assign(test_msg_.use_bds_sat, 3); + assign(test_msg_.use_gal_sat, 2); + assign(test_msg_.use_gps_sat, 1); + assign(test_msg_.use_iono_grid_point_sat_los, 8); + assign(test_msg_.use_iono_grid_points, 6); + assign(test_msg_.use_iono_tile_sat_los, 7); + assign(test_msg_.use_qzss_sat, 4); + assign(test_msg_.use_tropo_grid_points, 5); + } + + class SlowReader final : public sbp::IReader { + public: + SlowReader(const uint8_t *buf, uint32_t len) + : sbp::IReader(), buf_{buf}, len_{len} {} + + s32 read(uint8_t *buf, const uint32_t n) override { + if (n == 0) { + return 0; + } + if (remaining() == 0) { + return -1; + } + skip_next_read = !skip_next_read; + if (skip_next_read) { + return 0; + } + uint32_t real_n = std::min(n, 1u); + memcpy(buf, buf_ + offset_, real_n); + offset_ += real_n; + return static_cast(real_n); + } + + uint32_t remaining() const noexcept { return len_ - offset_; } + + static s32 read_static(uint8_t *buf, uint32_t len, void *ctx) { + return static_cast(ctx)->read(buf, len); + } + + private: + const uint8_t *buf_; + uint32_t len_; + uint32_t offset_{}; + bool skip_next_read{}; + }; + + class Reader final : public sbp::IReader { + public: + Reader(const uint8_t *buf, uint32_t len) + : sbp::IReader(), buf_{buf}, len_{len} {} + + s32 read(uint8_t *buf, const uint32_t n) override { + if (n == 0) { + return 0; + } + uint32_t real_n = std::min(n, remaining()); + if (real_n == 0) { + return -1; + } + memcpy(buf, buf_ + offset_, real_n); + offset_ += real_n; + return static_cast(real_n); + } + + uint32_t remaining() const noexcept { return len_ - offset_; } + + static s32 read_static(uint8_t *buf, uint32_t len, void *ctx) { + return static_cast(ctx)->read(buf, len); + } + + private: + const uint8_t *buf_; + uint32_t len_; + uint32_t offset_{}; + }; + + class SlowWriter final : public sbp::IWriter { + public: + explicit SlowWriter(uint32_t max_len = cMaxLen) + : IWriter(), max_len_{max_len} {} + static constexpr uint32_t cMaxLen = SBP_MAX_FRAME_LEN; + + s32 write(const uint8_t *buf, uint32_t n) override { + if (n == 0) { + return 0; + } + uint32_t real_n = std::min(n, 1u); + if (real_n == 0) { + return -1; + } + memcpy(buf_ + offset_, buf, real_n); + offset_ += real_n; + return static_cast(real_n); + } + + uint32_t remaining() const noexcept { return max_len_ - offset_; } + + const uint8_t *data() const noexcept { return buf_; } + + uint32_t len() const noexcept { return offset_; } + + static s32 write_static(const uint8_t *buf, uint32_t len, void *ctx) { + return static_cast(ctx)->write(buf, len); + } + + static s32 write_c(uint8_t *buf, uint32_t len, void *ctx) { + return static_cast(ctx)->write(buf, len); + } + + private: + uint8_t buf_[cMaxLen]; + uint32_t max_len_; + uint32_t offset_{}; + }; + + class Writer final : public sbp::IWriter { + public: + explicit Writer(uint32_t max_len = cMaxLen) + : IWriter(), max_len_{max_len} {} + static constexpr uint32_t cMaxLen = SBP_MAX_FRAME_LEN; + + s32 write(const uint8_t *buf, uint32_t n) override { + if (n == 0) { + return 0; + } + uint32_t real_n = std::min(n, remaining()); + if (real_n == 0) { + return -1; + } + memcpy(buf_ + offset_, buf, real_n); + offset_ += real_n; + return static_cast(real_n); + } + + uint32_t remaining() const noexcept { return max_len_ - offset_; } + + const uint8_t *data() const noexcept { return buf_; } + + uint32_t len() const noexcept { return offset_; } + + static s32 write_static(const uint8_t *buf, uint32_t len, void *ctx) { + return static_cast(ctx)->write(buf, len); + } + + static s32 write_c(uint8_t *buf, uint32_t len, void *ctx) { + return static_cast(ctx)->write(buf, len); + } + + private: + uint8_t buf_[cMaxLen]; + uint32_t max_len_; + uint32_t offset_{}; + }; + + struct CppHandler final + : public sbp::MessageHandler { + using sbp::MessageHandler< + sbp_msg_ssr_flag_high_level_dep_a_t>::MessageHandler; + + struct Output final { + uint16_t sender_id; + sbp_msg_ssr_flag_high_level_dep_a_t msg; + }; + + std::vector outputs{}; + + protected: + void handle_sbp_msg( + uint16_t sender_id, + const sbp_msg_ssr_flag_high_level_dep_a_t &msg) override { + outputs.emplace_back(); + outputs.back().sender_id = sender_id; + memcpy(&outputs.back().msg, &msg, sizeof(msg)); + } + }; + + struct CHandler final { + explicit CHandler(sbp_state_t *state) : state_{state} { + sbp_callback_register(state, SbpMsgSsrFlagHighLevelDepA, + &CHandler::callback_static, this, &node_); + } + + ~CHandler() { sbp_remove_callback(state_, &node_); } + + struct Output final { + uint16_t sender_id; + sbp_msg_ssr_flag_high_level_dep_a_t msg; + }; + + std::vector outputs{}; + + private: + void callback(uint16_t sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg) { + ASSERT_EQ(msg_type, SbpMsgSsrFlagHighLevelDepA); + outputs.emplace_back(); + outputs.back().sender_id = sender_id; + memcpy(&outputs.back().msg, &msg->ssr_flag_high_level_dep_a, + sizeof(msg->ssr_flag_high_level_dep_a)); + } + + static void callback_static(uint16_t sender_id, sbp_msg_type_t msg_type, + const sbp_msg_t *msg, void *ctx) { + static_cast(ctx)->callback(sender_id, msg_type, msg); + } + + sbp_msg_callbacks_node_t node_{}; + sbp_state_t *state_; + }; + + struct TestMsgInfo { + sbp_msg_ssr_flag_high_level_dep_a_t test_msg; + sbp_msg_t test_msg_wrapped; + sbp_msg_type_t msg_type; + uint16_t sender_id; + uint8_t preamble; + uint16_t crc; + const uint8_t *encoded_frame; + uint32_t frame_len; + const uint8_t *encoded_payload; + uint8_t payload_len; + + Reader get_frame_reader() const noexcept { + return Reader{encoded_frame, frame_len}; + } + + Reader get_frame_reader(uint32_t max) const noexcept { + assert(max <= frame_len); + return Reader{encoded_frame, max}; + } + + SlowReader get_slow_frame_reader() const noexcept { + return SlowReader{encoded_frame, frame_len}; + } + + Writer get_frame_writer() const noexcept { return Writer{frame_len}; } + + Writer get_frame_writer(uint32_t max) const noexcept { return Writer{max}; } + + SlowWriter get_slow_frame_writer() const noexcept { + return SlowWriter{frame_len}; + } + }; + + TestMsgInfo get_test_msg_info() const noexcept { + TestMsgInfo info; + memcpy(&info.test_msg, &test_msg_, sizeof(test_msg_)); + memcpy(&info.test_msg_wrapped.ssr_flag_high_level_dep_a, &test_msg_, + sizeof(test_msg_)); + info.msg_type = static_cast(SbpMsgSsrFlagHighLevelDepA); + info.sender_id = 66; + info.preamble = 0x55; + info.crc = 0x0369; + info.encoded_frame = encoded_frame_; + info.frame_len = sizeof(encoded_frame_); + info.encoded_payload = encoded_payload_; + info.payload_len = 31; + + return info; + } + + protected: + void comparison_tests(const sbp_msg_ssr_flag_high_level_dep_a_t &lesser, + const sbp_msg_ssr_flag_high_level_dep_a_t &greater) { + sbp_msg_t wrapped_lesser = + sbp::MessageTraits::to_sbp_msg( + lesser); + sbp_msg_t wrapped_greater = + sbp::MessageTraits::to_sbp_msg( + greater); + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_cmp(&lesser, &lesser), 0); + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_cmp(&greater, &greater), 0); + EXPECT_LE(sbp_msg_ssr_flag_high_level_dep_a_cmp(&lesser, &greater), 0); + EXPECT_GT(sbp_msg_ssr_flag_high_level_dep_a_cmp(&greater, &lesser), 0); + + EXPECT_EQ(sbp_message_cmp(SbpMsgSsrFlagHighLevelDepA, &wrapped_lesser, + &wrapped_lesser), + 0); + EXPECT_EQ(sbp_message_cmp(SbpMsgSsrFlagHighLevelDepA, &wrapped_greater, + &wrapped_greater), + 0); + EXPECT_LE(sbp_message_cmp(SbpMsgSsrFlagHighLevelDepA, &wrapped_lesser, + &wrapped_greater), + 0); + EXPECT_GT(sbp_message_cmp(SbpMsgSsrFlagHighLevelDepA, &wrapped_greater, + &wrapped_lesser), + 0); + + // lesser vs lesser + EXPECT_TRUE(lesser == lesser); + EXPECT_FALSE(lesser != lesser); + EXPECT_FALSE(lesser < lesser); + EXPECT_TRUE(lesser <= lesser); + EXPECT_FALSE(lesser > lesser); + EXPECT_TRUE(lesser >= lesser); + + // greater vs greater + EXPECT_TRUE(greater == greater); + EXPECT_FALSE(greater != greater); + EXPECT_FALSE(greater < greater); + EXPECT_TRUE(greater <= greater); + EXPECT_FALSE(greater > greater); + EXPECT_TRUE(greater >= greater); + + // lesser vs greater + EXPECT_FALSE(lesser == greater); + EXPECT_TRUE(lesser != greater); + EXPECT_TRUE(lesser < greater); + EXPECT_TRUE(lesser <= greater); + EXPECT_FALSE(lesser > greater); + EXPECT_FALSE(lesser >= greater); + + // greater vs lesser + EXPECT_FALSE(greater == lesser); + EXPECT_TRUE(greater != lesser); + EXPECT_FALSE(greater < lesser); + EXPECT_FALSE(greater <= lesser); + EXPECT_TRUE(greater > lesser); + EXPECT_TRUE(greater >= lesser); + } + + template ::value, bool> = true> + void make_lesser_greater(T &lesser, T &greater) { + if (lesser > std::numeric_limits::min()) { + lesser--; + } else { + greater++; + } + } + + template ::value, bool> = true> + void make_lesser_greater(T &lesser, T &greater) { + (void)lesser; + greater += static_cast(1.0); + } + + void make_lesser_greater(sbp_string_t &lesser, sbp_string_t &greater) { + if (greater.data[0] == 'z') { + lesser.data[0]--; + } else { + greater.data[0]++; + } + } + + template + void make_lesser_greater(char (&lesser)[N], char (&greater)[N]) { + if (lesser[0] == 'z') { + lesser[0]--; + } else { + greater[0]++; + } + } + + private: + sbp_msg_ssr_flag_high_level_dep_a_t test_msg_{}; + uint8_t encoded_frame_[31 + 8] = { + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, + 0, 30, 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + }; + uint8_t encoded_payload_[31] = { + 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, + 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, + }; +}; + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, EncodedLen) { + auto info = get_test_msg_info(); + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_encoded_len(&info.test_msg), + info.payload_len); + + EXPECT_EQ(sbp_message_encoded_len(SbpMsgSsrFlagHighLevelDepA, + &info.test_msg_wrapped), + info.payload_len); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, EncodeToBuf) { + auto info = get_test_msg_info(); + uint8_t buf[31]; + uint8_t n_written; + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_encode( + &buf[0], sizeof(buf), &n_written, &info.test_msg), + SBP_OK); + EXPECT_EQ(n_written, 31); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); + + memset(&buf[0], 0, sizeof(buf)); + EXPECT_EQ( + sbp_message_encode(&buf[0], sizeof(buf), &n_written, + SbpMsgSsrFlagHighLevelDepA, &info.test_msg_wrapped), + SBP_OK); + EXPECT_EQ(n_written, 31); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + EncodeToBufWithoutNwritten) { + auto info = get_test_msg_info(); + uint8_t buf[31]; + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_encode(&buf[0], sizeof(buf), + nullptr, &info.test_msg), + SBP_OK); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); +} +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + EncodedToBufUnderflow) { + auto info = get_test_msg_info(); + uint8_t buf[31]; + + for (uint8_t i = 0; i < 31; i++) { + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_encode(&buf[0], i, nullptr, + &info.test_msg), + SBP_ENCODE_ERROR); + } +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, DecodeFromBuf) { + auto info = get_test_msg_info(); + sbp_msg_ssr_flag_high_level_dep_a_t msg{}; + uint8_t n_read; + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_decode( + &info.encoded_payload[0], info.payload_len, &n_read, &msg), + SBP_OK); + EXPECT_EQ(n_read, 31); + EXPECT_EQ(msg, info.test_msg); + + sbp_msg_t wrapped_msg{}; + EXPECT_EQ( + sbp_message_decode(&info.encoded_payload[0], info.payload_len, &n_read, + SbpMsgSsrFlagHighLevelDepA, &wrapped_msg), + SBP_OK); + EXPECT_EQ(n_read, 31); + EXPECT_EQ(msg, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + DecodeFromBufWithoutNread) { + auto info = get_test_msg_info(); + sbp_msg_ssr_flag_high_level_dep_a_t msg{}; + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_decode( + &info.encoded_payload[0], info.payload_len, nullptr, &msg), + SBP_OK); + EXPECT_EQ(msg, info.test_msg); +} +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + DecodeFromBufUnderflow) { + auto info = get_test_msg_info(); + sbp_msg_ssr_flag_high_level_dep_a_t msg{}; + + for (uint8_t i = 0; i < info.payload_len; i++) { + int expected_return = SBP_DECODE_ERROR; + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_decode(&info.encoded_payload[0], + i, nullptr, &msg), + expected_return); + } +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + ReceiveThroughSbpState) { + auto info = get_test_msg_info(); + sbp_state_t state; + sbp_state_init(&state); + + auto reader = info.get_frame_reader(); + sbp_state_set_io_context(&state, &reader); + + CHandler handler{&state}; + + while (reader.remaining() > 0) { + EXPECT_GE(sbp_process(&state, &Reader::read_static), SBP_OK); + } + + EXPECT_EQ(handler.outputs.size(), 1); + EXPECT_EQ(handler.outputs[0].sender_id, info.sender_id); + EXPECT_EQ(handler.outputs[0].msg, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + ReceiveThroughSbpStateUnderflow) { + auto info = get_test_msg_info(); + + for (uint32_t i = 0; i < info.frame_len; i++) { + sbp_state_t state; + sbp_state_init(&state); + + auto reader = info.get_frame_reader(i); + sbp_state_set_io_context(&state, &reader); + + CHandler handler(&state); + + int most_recent_return = sbp_process(&state, &Reader::read_static); + while (most_recent_return == SBP_OK || reader.remaining() > 0) { + most_recent_return = sbp_process(&state, &Reader::read_static); + } + + EXPECT_NE(most_recent_return, SBP_OK); + EXPECT_EQ(reader.remaining(), 0); + + EXPECT_EQ(handler.outputs.size(), 0); + } +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, SlowRead) { + auto info = get_test_msg_info(); + sbp_state_t state; + sbp_state_init(&state); + + auto reader = info.get_slow_frame_reader(); + sbp_state_set_io_context(&state, &reader); + + CHandler handler{&state}; + + while (reader.remaining() > 0) { + EXPECT_GE(sbp_process(&state, &SlowReader::read_static), SBP_OK); + } + + EXPECT_EQ(handler.outputs.size(), 1); + EXPECT_EQ(handler.outputs[0].sender_id, info.sender_id); + EXPECT_EQ(handler.outputs[0].msg, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, BadCRC) { + auto info = get_test_msg_info(); + uint8_t buf[SBP_MAX_FRAME_LEN]; + memcpy(&buf[0], info.encoded_frame, info.frame_len); + + // Introduce a CRC error which should cause an error return and no callback + buf[info.frame_len - 1]++; + + sbp_state_t state; + sbp_state_init(&state); + + Reader reader{buf, info.frame_len}; + sbp_state_set_io_context(&state, &reader); + + CHandler handler{&state}; + + while (reader.remaining() > 0) { + int res = sbp_process(&state, &Reader::read_static); + EXPECT_EQ(res, reader.remaining() == 0 ? SBP_CRC_ERROR : SBP_OK); + } + + EXPECT_EQ(handler.outputs.size(), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + SendThroughSbpState) { + auto info = get_test_msg_info(); + sbp_state_t state; + sbp_state_init(&state); + + auto writer = info.get_frame_writer(); + sbp_state_set_io_context(&state, &writer); + + EXPECT_EQ(sbp_msg_ssr_flag_high_level_dep_a_send( + &state, info.sender_id, &info.test_msg, &Writer::write_c), + SBP_OK); + EXPECT_EQ(writer.len(), info.frame_len); + EXPECT_EQ(memcmp(writer.data(), &info.encoded_frame[0], writer.len()), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + SendWrappedThroughSbpState) { + auto info = get_test_msg_info(); + sbp_state_t state; + sbp_state_init(&state); + + auto writer = info.get_frame_writer(); + sbp_state_set_io_context(&state, &writer); + + EXPECT_EQ(sbp_message_send(&state, SbpMsgSsrFlagHighLevelDepA, info.sender_id, + &info.test_msg_wrapped, &Writer::write_c), + SBP_OK); + EXPECT_EQ(writer.len(), info.frame_len); + EXPECT_EQ(memcmp(writer.data(), info.encoded_frame, info.frame_len), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + SendThroughSbpStateUnderflow) { + auto info = get_test_msg_info(); + + for (uint32_t i = 0; i < info.frame_len; i++) { + sbp_state_t state; + sbp_state_init(&state); + + auto writer = info.get_frame_writer(i); + sbp_state_set_io_context(&state, &writer); + + EXPECT_NE( + sbp_message_send(&state, SbpMsgSsrFlagHighLevelDepA, info.sender_id, + &info.test_msg_wrapped, &Writer::write_c), + SBP_OK); + EXPECT_EQ(writer.len(), i); + EXPECT_EQ(memcmp(writer.data(), info.encoded_frame, i), 0); + } +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + DISABLED_SlowWrite) { + auto info = get_test_msg_info(); + sbp_state_t state; + sbp_state_init(&state); + + auto writer = info.get_slow_frame_writer(); + sbp_state_set_io_context(&state, &writer); + + EXPECT_EQ(sbp_message_send(&state, SbpMsgSsrFlagHighLevelDepA, info.sender_id, + &info.test_msg_wrapped, &SlowWriter::write_c), + SBP_OK); + EXPECT_EQ(writer.len(), info.frame_len); + EXPECT_EQ(memcmp(writer.data(), info.encoded_frame, info.frame_len), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, Comparison) { + auto info = get_test_msg_info(); + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.chain_id, greater.chain_id); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.corr_time.tow, greater.corr_time.tow); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.corr_time.wn, greater.corr_time.wn); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.obs_time.tow, greater.obs_time.tow); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.obs_time.wn, greater.obs_time.wn); + comparison_tests(lesser, greater); + } + + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.reserved[0], greater.reserved[0]); + comparison_tests(lesser, greater); + } + + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.reserved[1], greater.reserved[1]); + comparison_tests(lesser, greater); + } + + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.reserved[2], greater.reserved[2]); + comparison_tests(lesser, greater); + } + + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.reserved[3], greater.reserved[3]); + comparison_tests(lesser, greater); + } + + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.reserved[4], greater.reserved[4]); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.ssr_sol_id, greater.ssr_sol_id); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.tile_id, greater.tile_id); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.tile_set_id, greater.tile_set_id); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_bds_sat, greater.use_bds_sat); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_gal_sat, greater.use_gal_sat); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_gps_sat, greater.use_gps_sat); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_iono_grid_point_sat_los, + greater.use_iono_grid_point_sat_los); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_iono_grid_points, + greater.use_iono_grid_points); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_iono_tile_sat_los, + greater.use_iono_tile_sat_los); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_qzss_sat, greater.use_qzss_sat); + comparison_tests(lesser, greater); + } + { + sbp_msg_ssr_flag_high_level_dep_a_t lesser = info.test_msg; + sbp_msg_ssr_flag_high_level_dep_a_t greater = info.test_msg; + make_lesser_greater(lesser.use_tropo_grid_points, + greater.use_tropo_grid_points); + comparison_tests(lesser, greater); + } +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsProperties) { + // EXPECT_EQ(sbp::MessageTraits::id, + // SbpMsgSsrFlagHighLevelDepA); + EXPECT_STREQ(sbp::MessageTraits::name, + "MSG_SSR_FLAG_HIGH_LEVEL_DEP_A"); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsFromSbpMsgT) { + auto info = get_test_msg_info(); + + const sbp_msg_t &const_sbp_msg_t = info.test_msg_wrapped; + sbp_msg_t &non_const_sbp_msg_t = info.test_msg_wrapped; + + const sbp_msg_ssr_flag_high_level_dep_a_t &const_unwrapped = + sbp::MessageTraits::get( + const_sbp_msg_t); + sbp_msg_ssr_flag_high_level_dep_a_t &non_const_unwrapped = + sbp::MessageTraits::get( + non_const_sbp_msg_t); + + EXPECT_EQ((const void *)&const_sbp_msg_t, (const void *)&const_unwrapped); + EXPECT_EQ((void *)&non_const_sbp_msg_t, (void *)&non_const_unwrapped); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsToSbpMsgT) { + auto info = get_test_msg_info(); + + sbp_msg_t msg1 = + sbp::MessageTraits::to_sbp_msg( + info.test_msg); + EXPECT_EQ(msg1.ssr_flag_high_level_dep_a, info.test_msg); + + sbp_msg_t msg2; + sbp::MessageTraits::to_sbp_msg( + info.test_msg, &msg2); + EXPECT_EQ(msg2.ssr_flag_high_level_dep_a, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsEncodedLen) { + auto info = get_test_msg_info(); + EXPECT_EQ( + sbp::MessageTraits::encoded_len( + info.test_msg), + info.payload_len); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsSendThroughSbpState) { + auto info = get_test_msg_info(); + sbp_state_t state; + sbp_state_init(&state); + + auto writer = info.get_frame_writer(); + sbp_state_set_io_context(&state, &writer); + + EXPECT_EQ(sbp::MessageTraits::send( + &state, info.sender_id, info.test_msg, &Writer::write_c), + SBP_OK); + EXPECT_EQ(writer.len(), info.frame_len); + EXPECT_EQ(memcmp(writer.data(), &info.encoded_frame[0], writer.len()), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsEncodeToBuf) { + auto info = get_test_msg_info(); + uint8_t buf[31]; + uint8_t n_written; + + EXPECT_EQ(sbp::MessageTraits::encode( + &buf[0], sizeof(buf), &n_written, info.test_msg), + SBP_OK); + EXPECT_EQ(n_written, 31); + EXPECT_EQ(memcmp(&buf[0], info.encoded_payload, 31), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + CppTraitsDecodeFromBuf) { + auto info = get_test_msg_info(); + sbp_msg_ssr_flag_high_level_dep_a_t msg{}; + uint8_t n_read; + + EXPECT_EQ(sbp::MessageTraits::decode( + &info.encoded_payload[0], info.payload_len, &n_read, &msg), + SBP_OK); + EXPECT_EQ(n_read, 31); + EXPECT_EQ(msg, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + ReceiveThroughMessageHandler) { + auto info = get_test_msg_info(); + auto reader = info.get_frame_reader(); + + sbp::State state{}; + state.set_reader(&reader); + + CppHandler handler{&state}; + + while (reader.remaining() > 0) { + EXPECT_GE(state.process(), SBP_OK); + } + + EXPECT_EQ(handler.outputs.size(), 1); + EXPECT_EQ(handler.outputs[0].sender_id, info.sender_id); + EXPECT_EQ(handler.outputs[0].msg, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + ProcessSbpMsgTThroughMessageHandler) { + auto info = get_test_msg_info(); + sbp::State state{}; + CppHandler handler(&state); + + state.process_message(info.sender_id, SbpMsgSsrFlagHighLevelDepA, + &info.test_msg_wrapped); + + EXPECT_EQ(handler.outputs.size(), 1); + EXPECT_EQ(handler.outputs[0].sender_id, info.sender_id); + EXPECT_EQ(handler.outputs[0].msg, info.test_msg); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + SendThroughCppState) { + auto info = get_test_msg_info(); + auto writer = info.get_frame_writer(); + + sbp::State state{}; + state.set_writer(&writer); + + EXPECT_EQ(state.send_message(info.sender_id, info.test_msg), SBP_OK); + EXPECT_EQ(writer.len(), info.frame_len); + EXPECT_EQ(memcmp(writer.data(), info.encoded_frame, info.frame_len), 0); +} + +TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevelDepA0, + SendWrappedSbpMsgTThroughCppState) { + auto info = get_test_msg_info(); + auto writer = info.get_frame_writer(); + + sbp::State state{}; + state.set_writer(&writer); + + EXPECT_EQ(state.send_message(info.sender_id, SbpMsgSsrFlagHighLevelDepA, + info.test_msg_wrapped), + SBP_OK); + EXPECT_EQ(writer.len(), info.frame_len); + EXPECT_EQ(memcmp(writer.data(), info.encoded_frame, info.frame_len), 0); +} + +} // namespace diff --git a/docs/sbp.pdf b/docs/sbp.pdf index a9e6a283906d26dd1b8461331677f2a7e6051160..5cdc5a75fcc343969db00b7c620481c79c93ffb0 100644 GIT binary patch delta 125755 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 j;055^=n3Wft-AKo+-m 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 delta 125516 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 diff --git a/haskell/src/SwiftNav/SBP/Integrity.hs b/haskell/src/SwiftNav/SBP/Integrity.hs index f4782d9d5..ad0dd7dee 100644 --- a/haskell/src/SwiftNav/SBP/Integrity.hs +++ b/haskell/src/SwiftNav/SBP/Integrity.hs @@ -76,10 +76,89 @@ instance Binary IntegritySSRHeader where $(makeJSON "_integritySSRHeader_" ''IntegritySSRHeader) $(makeLenses ''IntegritySSRHeader) +msgSsrFlagHighLevelDepA :: Word16 +msgSsrFlagHighLevelDepA = 0x0BB9 + +-- | SBP class for message MSG_SSR_FLAG_HIGH_LEVEL_DEP_A (0x0BB9). +-- +-- Deprecated. +data MsgSsrFlagHighLevelDepA = MsgSsrFlagHighLevelDepA + { _msgSsrFlagHighLevelDepA_obs_time :: !GpsTimeSec + -- ^ GNSS reference time of the observation used to generate the flag. + , _msgSsrFlagHighLevelDepA_corr_time :: !GpsTimeSec + -- ^ GNSS reference time of the correction associated to the flag. + , _msgSsrFlagHighLevelDepA_ssr_sol_id :: !Word8 + -- ^ SSR Solution ID. + , _msgSsrFlagHighLevelDepA_tile_set_id :: !Word16 + -- ^ Unique identifier of the set this tile belongs to. + , _msgSsrFlagHighLevelDepA_tile_id :: !Word16 + -- ^ Unique identifier of this tile in the tile set. + , _msgSsrFlagHighLevelDepA_chain_id :: !Word8 + -- ^ Chain and type of flag. + , _msgSsrFlagHighLevelDepA_use_gps_sat :: !Word8 + -- ^ Use GPS satellites. + , _msgSsrFlagHighLevelDepA_use_gal_sat :: !Word8 + -- ^ Use GAL satellites. + , _msgSsrFlagHighLevelDepA_use_bds_sat :: !Word8 + -- ^ Use BDS satellites. + , _msgSsrFlagHighLevelDepA_use_qzss_sat :: !Word8 + -- ^ Use QZSS satellites. + , _msgSsrFlagHighLevelDepA_reserved :: ![Word8] + -- ^ Reserved + , _msgSsrFlagHighLevelDepA_use_tropo_grid_points :: !Word8 + -- ^ Use tropo grid points. + , _msgSsrFlagHighLevelDepA_use_iono_grid_points :: !Word8 + -- ^ Use iono grid points. + , _msgSsrFlagHighLevelDepA_use_iono_tile_sat_los :: !Word8 + -- ^ Use iono tile satellite LoS. + , _msgSsrFlagHighLevelDepA_use_iono_grid_point_sat_los :: !Word8 + -- ^ Use iono grid point satellite LoS. + } deriving ( Show, Read, Eq ) + +instance Binary MsgSsrFlagHighLevelDepA where + get = do + _msgSsrFlagHighLevelDepA_obs_time <- get + _msgSsrFlagHighLevelDepA_corr_time <- get + _msgSsrFlagHighLevelDepA_ssr_sol_id <- getWord8 + _msgSsrFlagHighLevelDepA_tile_set_id <- getWord16le + _msgSsrFlagHighLevelDepA_tile_id <- getWord16le + _msgSsrFlagHighLevelDepA_chain_id <- getWord8 + _msgSsrFlagHighLevelDepA_use_gps_sat <- getWord8 + _msgSsrFlagHighLevelDepA_use_gal_sat <- getWord8 + _msgSsrFlagHighLevelDepA_use_bds_sat <- getWord8 + _msgSsrFlagHighLevelDepA_use_qzss_sat <- getWord8 + _msgSsrFlagHighLevelDepA_reserved <- replicateM 5 getWord8 + _msgSsrFlagHighLevelDepA_use_tropo_grid_points <- getWord8 + _msgSsrFlagHighLevelDepA_use_iono_grid_points <- getWord8 + _msgSsrFlagHighLevelDepA_use_iono_tile_sat_los <- getWord8 + _msgSsrFlagHighLevelDepA_use_iono_grid_point_sat_los <- getWord8 + pure MsgSsrFlagHighLevelDepA {..} + + put MsgSsrFlagHighLevelDepA {..} = do + put _msgSsrFlagHighLevelDepA_obs_time + put _msgSsrFlagHighLevelDepA_corr_time + putWord8 _msgSsrFlagHighLevelDepA_ssr_sol_id + putWord16le _msgSsrFlagHighLevelDepA_tile_set_id + putWord16le _msgSsrFlagHighLevelDepA_tile_id + putWord8 _msgSsrFlagHighLevelDepA_chain_id + putWord8 _msgSsrFlagHighLevelDepA_use_gps_sat + putWord8 _msgSsrFlagHighLevelDepA_use_gal_sat + putWord8 _msgSsrFlagHighLevelDepA_use_bds_sat + putWord8 _msgSsrFlagHighLevelDepA_use_qzss_sat + mapM_ putWord8 _msgSsrFlagHighLevelDepA_reserved + putWord8 _msgSsrFlagHighLevelDepA_use_tropo_grid_points + putWord8 _msgSsrFlagHighLevelDepA_use_iono_grid_points + putWord8 _msgSsrFlagHighLevelDepA_use_iono_tile_sat_los + putWord8 _msgSsrFlagHighLevelDepA_use_iono_grid_point_sat_los + +$(makeSBP 'msgSsrFlagHighLevelDepA ''MsgSsrFlagHighLevelDepA) +$(makeJSON "_msgSsrFlagHighLevelDepA_" ''MsgSsrFlagHighLevelDepA) +$(makeLenses ''MsgSsrFlagHighLevelDepA) + msgSsrFlagHighLevel :: Word16 -msgSsrFlagHighLevel = 0x0BB9 +msgSsrFlagHighLevel = 0x0BBA --- | SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BB9). +-- | SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BBA). -- -- Integrity monitoring flags for multiple aggregated elements. An element -- could be a satellite, SSR grid point, or SSR tile. A group of aggregated @@ -109,8 +188,11 @@ msgSsrFlagHighLevel = 0x0BB9 data MsgSsrFlagHighLevel = MsgSsrFlagHighLevel { _msgSsrFlagHighLevel_obs_time :: !GpsTimeSec -- ^ GNSS reference time of the observation used to generate the flag. - , _msgSsrFlagHighLevel_corr_time :: !GpsTimeSec - -- ^ GNSS reference time of the correction associated to the flag. + , _msgSsrFlagHighLevel_atmo_corr_time :: !GpsTimeSec + -- ^ GNSS reference time of the atmospheric correction associated to the + -- flag. + , _msgSsrFlagHighLevel_sat_corr_time :: !GpsTimeSec + -- ^ GNSS reference time of the satellite correction associated to the flag. , _msgSsrFlagHighLevel_ssr_sol_id :: !Word8 -- ^ SSR Solution ID. , _msgSsrFlagHighLevel_tile_set_id :: !Word16 @@ -142,7 +224,8 @@ data MsgSsrFlagHighLevel = MsgSsrFlagHighLevel instance Binary MsgSsrFlagHighLevel where get = do _msgSsrFlagHighLevel_obs_time <- get - _msgSsrFlagHighLevel_corr_time <- get + _msgSsrFlagHighLevel_atmo_corr_time <- get + _msgSsrFlagHighLevel_sat_corr_time <- get _msgSsrFlagHighLevel_ssr_sol_id <- getWord8 _msgSsrFlagHighLevel_tile_set_id <- getWord16le _msgSsrFlagHighLevel_tile_id <- getWord16le @@ -160,7 +243,8 @@ instance Binary MsgSsrFlagHighLevel where put MsgSsrFlagHighLevel {..} = do put _msgSsrFlagHighLevel_obs_time - put _msgSsrFlagHighLevel_corr_time + put _msgSsrFlagHighLevel_atmo_corr_time + put _msgSsrFlagHighLevel_sat_corr_time putWord8 _msgSsrFlagHighLevel_ssr_sol_id putWord16le _msgSsrFlagHighLevel_tile_set_id putWord16le _msgSsrFlagHighLevel_tile_id diff --git a/haskell/src/SwiftNav/SBP/Msg.hs b/haskell/src/SwiftNav/SBP/Msg.hs index cbd229261..06b92befa 100644 --- a/haskell/src/SwiftNav/SBP/Msg.hs +++ b/haskell/src/SwiftNav/SBP/Msg.hs @@ -237,6 +237,7 @@ data SBPMsg = | SBPMsgSsrCodeBiases MsgSsrCodeBiases Msg | SBPMsgSsrCodePhaseBiasesBounds MsgSsrCodePhaseBiasesBounds Msg | SBPMsgSsrFlagHighLevel MsgSsrFlagHighLevel Msg + | SBPMsgSsrFlagHighLevelDepA MsgSsrFlagHighLevelDepA Msg | SBPMsgSsrFlagIonoGridPointSatLos MsgSsrFlagIonoGridPointSatLos Msg | SBPMsgSsrFlagIonoGridPoints MsgSsrFlagIonoGridPoints Msg | SBPMsgSsrFlagIonoTileSatLos MsgSsrFlagIonoTileSatLos Msg @@ -489,6 +490,7 @@ instance Binary SBPMsg where | _msgSBPType == msgSsrCodeBiases = SBPMsgSsrCodeBiases (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrCodePhaseBiasesBounds = SBPMsgSsrCodePhaseBiasesBounds (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrFlagHighLevel = SBPMsgSsrFlagHighLevel (decode (fromStrict (unBytes _msgSBPPayload))) m + | _msgSBPType == msgSsrFlagHighLevelDepA = SBPMsgSsrFlagHighLevelDepA (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrFlagIonoGridPointSatLos = SBPMsgSsrFlagIonoGridPointSatLos (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrFlagIonoGridPoints = SBPMsgSsrFlagIonoGridPoints (decode (fromStrict (unBytes _msgSBPPayload))) m | _msgSBPType == msgSsrFlagIonoTileSatLos = SBPMsgSsrFlagIonoTileSatLos (decode (fromStrict (unBytes _msgSBPPayload))) m @@ -733,6 +735,7 @@ instance Binary SBPMsg where encoder (SBPMsgSsrCodeBiases _ m) = put m encoder (SBPMsgSsrCodePhaseBiasesBounds _ m) = put m encoder (SBPMsgSsrFlagHighLevel _ m) = put m + encoder (SBPMsgSsrFlagHighLevelDepA _ m) = put m encoder (SBPMsgSsrFlagIonoGridPointSatLos _ m) = put m encoder (SBPMsgSsrFlagIonoGridPoints _ m) = put m encoder (SBPMsgSsrFlagIonoTileSatLos _ m) = put m @@ -981,6 +984,7 @@ instance FromJSON SBPMsg where | msgType == msgSsrCodeBiases = SBPMsgSsrCodeBiases <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrCodePhaseBiasesBounds = SBPMsgSsrCodePhaseBiasesBounds <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrFlagHighLevel = SBPMsgSsrFlagHighLevel <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj + | msgType == msgSsrFlagHighLevelDepA = SBPMsgSsrFlagHighLevelDepA <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrFlagIonoGridPointSatLos = SBPMsgSsrFlagIonoGridPointSatLos <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrFlagIonoGridPoints = SBPMsgSsrFlagIonoGridPoints <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj | msgType == msgSsrFlagIonoTileSatLos = SBPMsgSsrFlagIonoTileSatLos <$> pure (decode (fromStrict (unBytes payload))) <*> parseJSON obj @@ -1230,6 +1234,7 @@ instance ToJSON SBPMsg where toJSON (SBPMsgSsrCodeBiases n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrCodePhaseBiasesBounds n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrFlagHighLevel n m) = toJSON n <<>> toJSON m + toJSON (SBPMsgSsrFlagHighLevelDepA n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrFlagIonoGridPointSatLos n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrFlagIonoGridPoints n m) = toJSON n <<>> toJSON m toJSON (SBPMsgSsrFlagIonoTileSatLos n m) = toJSON n <<>> toJSON m @@ -1473,6 +1478,7 @@ instance HasMsg SBPMsg where msg f (SBPMsgSsrCodeBiases n m) = SBPMsgSsrCodeBiases n <$> f m msg f (SBPMsgSsrCodePhaseBiasesBounds n m) = SBPMsgSsrCodePhaseBiasesBounds n <$> f m msg f (SBPMsgSsrFlagHighLevel n m) = SBPMsgSsrFlagHighLevel n <$> f m + msg f (SBPMsgSsrFlagHighLevelDepA n m) = SBPMsgSsrFlagHighLevelDepA n <$> f m msg f (SBPMsgSsrFlagIonoGridPointSatLos n m) = SBPMsgSsrFlagIonoGridPointSatLos n <$> f m msg f (SBPMsgSsrFlagIonoGridPoints n m) = SBPMsgSsrFlagIonoGridPoints n <$> f m msg f (SBPMsgSsrFlagIonoTileSatLos n m) = SBPMsgSsrFlagIonoTileSatLos n <$> f m diff --git a/java/src/com/swiftnav/sbp/client/MessageTable.java b/java/src/com/swiftnav/sbp/client/MessageTable.java index 9a992a1cc..098d3d731 100644 --- a/java/src/com/swiftnav/sbp/client/MessageTable.java +++ b/java/src/com/swiftnav/sbp/client/MessageTable.java @@ -50,6 +50,7 @@ import com.swiftnav.sbp.imu.MsgImuRaw; import com.swiftnav.sbp.integrity.MsgAcknowledge; import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevel; +import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevelDepA; import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPointSatLos; import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPoints; import com.swiftnav.sbp.integrity.MsgSsrFlagIonoTileSatLos; @@ -326,6 +327,8 @@ static SBPMessage dispatch(SBPMessage msg) throws SBPBinaryException { return new MsgImuAux(msg); case MsgImuComp.TYPE: return new MsgImuComp(msg); + case MsgSsrFlagHighLevelDepA.TYPE: + return new MsgSsrFlagHighLevelDepA(msg); case MsgSsrFlagHighLevel.TYPE: return new MsgSsrFlagHighLevel(msg); case MsgSsrFlagSatellites.TYPE: diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java index 1c722941d..08f80dc75 100644 --- a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java @@ -21,7 +21,7 @@ import org.json.JSONObject; /** - * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BB9). + * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BBA). * *

You can have MSG_SSR_FLAG_HIGH_LEVEL inherent its fields directly from an inherited SBP * object, or construct it inline using a dict of its fields. @@ -52,13 +52,16 @@ * group. */ public class MsgSsrFlagHighLevel extends SBPMessage { - public static final int TYPE = 0x0BB9; + public static final int TYPE = 0x0BBA; /** GNSS reference time of the observation used to generate the flag. */ public GPSTimeSec obs_time; - /** GNSS reference time of the correction associated to the flag. */ - public GPSTimeSec corr_time; + /** GNSS reference time of the atmospheric correction associated to the flag. */ + public GPSTimeSec atmo_corr_time; + + /** GNSS reference time of the satellite correction associated to the flag. */ + public GPSTimeSec sat_corr_time; /** SSR Solution ID. */ public int ssr_sol_id; @@ -111,14 +114,15 @@ public MsgSsrFlagHighLevel(SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) throw new SBPBinaryException( - "Type mismatch for MsgSsrFlagHighLevel, expected 3001, actual " + msg.type); + "Type mismatch for MsgSsrFlagHighLevel, expected 3002, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ obs_time = new GPSTimeSec().parse(parser); - corr_time = new GPSTimeSec().parse(parser); + atmo_corr_time = new GPSTimeSec().parse(parser); + sat_corr_time = new GPSTimeSec().parse(parser); ssr_sol_id = parser.getU8(); tile_set_id = parser.getU16(); tile_id = parser.getU16(); @@ -137,7 +141,8 @@ protected void parse(Parser parser) throws SBPBinaryException { @Override protected void build(Builder builder) { obs_time.build(builder); - corr_time.build(builder); + atmo_corr_time.build(builder); + sat_corr_time.build(builder); builder.putU8(ssr_sol_id); builder.putU16(tile_set_id); builder.putU16(tile_id); @@ -157,7 +162,8 @@ protected void build(Builder builder) { public JSONObject toJSON() { JSONObject obj = super.toJSON(); obj.put("obs_time", obs_time.toJSON()); - obj.put("corr_time", corr_time.toJSON()); + obj.put("atmo_corr_time", atmo_corr_time.toJSON()); + obj.put("sat_corr_time", sat_corr_time.toJSON()); obj.put("ssr_sol_id", ssr_sol_id); obj.put("tile_set_id", tile_set_id); obj.put("tile_id", tile_id); diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevelDepA.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevelDepA.java new file mode 100644 index 000000000..cd42303ec --- /dev/null +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevelDepA.java @@ -0,0 +1,158 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.integrity; + +// This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. +// Do not modify by hand! + + +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.gnss.*; +import org.json.JSONArray; +import org.json.JSONObject; + +/** + * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL_DEP_A (0x0BB9). + * + *

You can have MSG_SSR_FLAG_HIGH_LEVEL_DEP_A inherent its fields directly from an inherited SBP + * object, or construct it inline using a dict of its fields. + * + *

Deprecated. + */ +public class MsgSsrFlagHighLevelDepA extends SBPMessage { + public static final int TYPE = 0x0BB9; + + /** GNSS reference time of the observation used to generate the flag. */ + public GPSTimeSec obs_time; + + /** GNSS reference time of the correction associated to the flag. */ + public GPSTimeSec corr_time; + + /** SSR Solution ID. */ + public int ssr_sol_id; + + /** Unique identifier of the set this tile belongs to. */ + public int tile_set_id; + + /** Unique identifier of this tile in the tile set. */ + public int tile_id; + + /** Chain and type of flag. */ + public int chain_id; + + /** Use GPS satellites. */ + public int use_gps_sat; + + /** Use GAL satellites. */ + public int use_gal_sat; + + /** Use BDS satellites. */ + public int use_bds_sat; + + /** Use QZSS satellites. */ + public int use_qzss_sat; + + /** Reserved */ + public int[] reserved; + + /** Use tropo grid points. */ + public int use_tropo_grid_points; + + /** Use iono grid points. */ + public int use_iono_grid_points; + + /** Use iono tile satellite LoS. */ + public int use_iono_tile_sat_los; + + /** Use iono grid point satellite LoS. */ + public int use_iono_grid_point_sat_los; + + public MsgSsrFlagHighLevelDepA(int sender) { + super(sender, TYPE); + } + + public MsgSsrFlagHighLevelDepA() { + super(TYPE); + } + + public MsgSsrFlagHighLevelDepA(SBPMessage msg) throws SBPBinaryException { + super(msg); + if (msg.type != TYPE) + throw new SBPBinaryException( + "Type mismatch for MsgSsrFlagHighLevelDepA, expected 3001, actual " + msg.type); + } + + @Override + protected void parse(Parser parser) throws SBPBinaryException { + /* Parse fields from binary */ + obs_time = new GPSTimeSec().parse(parser); + corr_time = new GPSTimeSec().parse(parser); + ssr_sol_id = parser.getU8(); + tile_set_id = parser.getU16(); + tile_id = parser.getU16(); + chain_id = parser.getU8(); + use_gps_sat = parser.getU8(); + use_gal_sat = parser.getU8(); + use_bds_sat = parser.getU8(); + use_qzss_sat = parser.getU8(); + reserved = parser.getArrayofU8(5); + use_tropo_grid_points = parser.getU8(); + use_iono_grid_points = parser.getU8(); + use_iono_tile_sat_los = parser.getU8(); + use_iono_grid_point_sat_los = parser.getU8(); + } + + @Override + protected void build(Builder builder) { + obs_time.build(builder); + corr_time.build(builder); + builder.putU8(ssr_sol_id); + builder.putU16(tile_set_id); + builder.putU16(tile_id); + builder.putU8(chain_id); + builder.putU8(use_gps_sat); + builder.putU8(use_gal_sat); + builder.putU8(use_bds_sat); + builder.putU8(use_qzss_sat); + builder.putArrayofU8(reserved, 5); + builder.putU8(use_tropo_grid_points); + builder.putU8(use_iono_grid_points); + builder.putU8(use_iono_tile_sat_los); + builder.putU8(use_iono_grid_point_sat_los); + } + + @Override + public JSONObject toJSON() { + JSONObject obj = super.toJSON(); + obj.put("obs_time", obs_time.toJSON()); + obj.put("corr_time", corr_time.toJSON()); + obj.put("ssr_sol_id", ssr_sol_id); + obj.put("tile_set_id", tile_set_id); + obj.put("tile_id", tile_id); + obj.put("chain_id", chain_id); + obj.put("use_gps_sat", use_gps_sat); + obj.put("use_gal_sat", use_gal_sat); + obj.put("use_bds_sat", use_bds_sat); + obj.put("use_qzss_sat", use_qzss_sat); + obj.put("reserved", new JSONArray(reserved)); + obj.put("use_tropo_grid_points", use_tropo_grid_points); + obj.put("use_iono_grid_points", use_iono_grid_points); + obj.put("use_iono_tile_sat_los", use_iono_tile_sat_los); + obj.put("use_iono_grid_point_sat_los", use_iono_grid_point_sat_los); + return obj; + } + + @Override + public String getFriendlyName() { + return "SSR FLAG HIGH LEVEL DEP A"; + } +} diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.java new file mode 100644 index 000000000..56d5f592c --- /dev/null +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.java @@ -0,0 +1,285 @@ +/* Copyright (C) 2015-2022 Swift Navigation Inc. + * Contact: https://support.swiftnav.com + * + * This source is subject to the license found in the file 'LICENSE' which must + * be distributed together with this source. All other rights reserved. + * + * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, + * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + */ +package com.swiftnav.sbp.test; + +// This file was auto-generated from +// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml by generate.py. Do not +// modify by hand! + + +import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevelDepA; +import java.math.BigInteger; +import org.json.JSONObject; +import org.junit.Test; + +public class auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest { + + public static boolean debug = false; + private static final double DELTA = 1e-15; + + @Test + public void test1() throws Throwable { + if (debug) + System.out.format( + "%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.test1"); + byte[] payload = + new byte[] { + (byte) 180, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 3, + (byte) 0, + (byte) 104, + (byte) 1, + (byte) 0, + (byte) 0, + (byte) 6, + (byte) 0, + (byte) 10, + (byte) 20, + (byte) 0, + (byte) 30, + (byte) 0, + (byte) 40, + (byte) 1, + (byte) 2, + (byte) 3, + (byte) 4, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 0, + (byte) 5, + (byte) 6, + (byte) 7, + (byte) 8, + }; + SBPMessage sbp = new SBPMessage(0x0042, 0x0BB9, payload); + MsgSsrFlagHighLevelDepA msg = new MsgSsrFlagHighLevelDepA(sbp); + JSONObject json = msg.toJSON(); + Number value; + Number expected; + value = msg.chain_id; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.chain_id + "' != '" + 40 + "'", + value.equals(BigInteger.valueOf(40L))); + } else { + value = value.longValue(); + expected = 40L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.corr_time.tow; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.corr_time.tow + "' != '" + 360 + "'", + value.equals(BigInteger.valueOf(360L))); + } else { + value = value.longValue(); + expected = 360L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.corr_time.wn; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.corr_time.wn + "' != '" + 6 + "'", + value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.obs_time.tow; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.obs_time.tow + "' != '" + 180 + "'", + value.equals(BigInteger.valueOf(180L))); + } else { + value = value.longValue(); + expected = 180L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.obs_time.wn; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.obs_time.wn + "' != '" + 3 + "'", + value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.reserved[0]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.reserved[0] + "' != '" + 0 + "'", + value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.reserved[1]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.reserved[1] + "' != '" + 0 + "'", + value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.reserved[2]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.reserved[2] + "' != '" + 0 + "'", + value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.reserved[3]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.reserved[3] + "' != '" + 0 + "'", + value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.reserved[4]; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.reserved[4] + "' != '" + 0 + "'", + value.equals(BigInteger.valueOf(0L))); + } else { + value = value.longValue(); + expected = 0L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.ssr_sol_id; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.ssr_sol_id + "' != '" + 10 + "'", + value.equals(BigInteger.valueOf(10L))); + } else { + value = value.longValue(); + expected = 10L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.tile_id; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.tile_id + "' != '" + 30 + "'", value.equals(BigInteger.valueOf(30L))); + } else { + value = value.longValue(); + expected = 30L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.tile_set_id; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.tile_set_id + "' != '" + 20 + "'", + value.equals(BigInteger.valueOf(20L))); + } else { + value = value.longValue(); + expected = 20L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_bds_sat; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_bds_sat + "' != '" + 3 + "'", + value.equals(BigInteger.valueOf(3L))); + } else { + value = value.longValue(); + expected = 3L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_gal_sat; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_gal_sat + "' != '" + 2 + "'", + value.equals(BigInteger.valueOf(2L))); + } else { + value = value.longValue(); + expected = 2L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_gps_sat; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_gps_sat + "' != '" + 1 + "'", + value.equals(BigInteger.valueOf(1L))); + } else { + value = value.longValue(); + expected = 1L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_iono_grid_point_sat_los; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_iono_grid_point_sat_los + "' != '" + 8 + "'", + value.equals(BigInteger.valueOf(8L))); + } else { + value = value.longValue(); + expected = 8L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_iono_grid_points; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_iono_grid_points + "' != '" + 6 + "'", + value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_iono_tile_sat_los; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_iono_tile_sat_los + "' != '" + 7 + "'", + value.equals(BigInteger.valueOf(7L))); + } else { + value = value.longValue(); + expected = 7L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_qzss_sat; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_qzss_sat + "' != '" + 4 + "'", + value.equals(BigInteger.valueOf(4L))); + } else { + value = value.longValue(); + expected = 4L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.use_tropo_grid_points; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.use_tropo_grid_points + "' != '" + 5 + "'", + value.equals(BigInteger.valueOf(5L))); + } else { + value = value.longValue(); + expected = 5L; + org.junit.Assert.assertEquals(value, expected); + } + + org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); + } +} diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java index 057924890..30a95941a 100644 --- a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java @@ -38,6 +38,12 @@ public void test1() throws Throwable { (byte) 0, (byte) 3, (byte) 0, + (byte) 109, + (byte) 1, + (byte) 0, + (byte) 0, + (byte) 6, + (byte) 0, (byte) 104, (byte) 1, (byte) 0, @@ -64,39 +70,39 @@ public void test1() throws Throwable { (byte) 7, (byte) 8, }; - SBPMessage sbp = new SBPMessage(0x0042, 0x0BB9, payload); + SBPMessage sbp = new SBPMessage(0x0042, 0x0BBA, payload); MsgSsrFlagHighLevel msg = new MsgSsrFlagHighLevel(sbp); JSONObject json = msg.toJSON(); Number value; Number expected; - value = msg.chain_id; + value = msg.atmo_corr_time.tow; if (value instanceof BigInteger) { org.junit.Assert.assertTrue( - "'" + msg.chain_id + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + "'" + msg.atmo_corr_time.tow + "' != '" + 365 + "'", + value.equals(BigInteger.valueOf(365L))); } else { value = value.longValue(); - expected = 40L; + expected = 365L; org.junit.Assert.assertEquals(value, expected); } - value = msg.corr_time.tow; + value = msg.atmo_corr_time.wn; if (value instanceof BigInteger) { org.junit.Assert.assertTrue( - "'" + msg.corr_time.tow + "' != '" + 360 + "'", - value.equals(BigInteger.valueOf(360L))); + "'" + msg.atmo_corr_time.wn + "' != '" + 6 + "'", + value.equals(BigInteger.valueOf(6L))); } else { value = value.longValue(); - expected = 360L; + expected = 6L; org.junit.Assert.assertEquals(value, expected); } - value = msg.corr_time.wn; + value = msg.chain_id; if (value instanceof BigInteger) { org.junit.Assert.assertTrue( - "'" + msg.corr_time.wn + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + "'" + msg.chain_id + "' != '" + 40 + "'", + value.equals(BigInteger.valueOf(40L))); } else { value = value.longValue(); - expected = 6L; + expected = 40L; org.junit.Assert.assertEquals(value, expected); } value = msg.obs_time.tow; @@ -169,6 +175,26 @@ public void test1() throws Throwable { expected = 0L; org.junit.Assert.assertEquals(value, expected); } + value = msg.sat_corr_time.tow; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.sat_corr_time.tow + "' != '" + 360 + "'", + value.equals(BigInteger.valueOf(360L))); + } else { + value = value.longValue(); + expected = 360L; + org.junit.Assert.assertEquals(value, expected); + } + value = msg.sat_corr_time.wn; + if (value instanceof BigInteger) { + org.junit.Assert.assertTrue( + "'" + msg.sat_corr_time.wn + "' != '" + 6 + "'", + value.equals(BigInteger.valueOf(6L))); + } else { + value = value.longValue(); + expected = 6L; + org.junit.Assert.assertEquals(value, expected); + } value = msg.ssr_sol_id; if (value instanceof BigInteger) { org.junit.Assert.assertTrue( diff --git a/javascript/sbp/integrity.js b/javascript/sbp/integrity.js index 883971014..555191b17 100644 --- a/javascript/sbp/integrity.js +++ b/javascript/sbp/integrity.js @@ -74,7 +74,76 @@ IntegritySSRHeader.prototype.fieldSpec.push(['tile_id', 'writeUInt16LE', 2]); IntegritySSRHeader.prototype.fieldSpec.push(['chain_id', 'writeUInt8', 1]); /** - * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BB9). + * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL_DEP_A (0x0BB9). + * + * Deprecated. + * + * Fields in the SBP payload (`sbp.payload`): + * @field obs_time GPSTimeSec GNSS reference time of the observation used to generate the flag. + * @field corr_time GPSTimeSec GNSS reference time of the correction associated to the flag. + * @field ssr_sol_id number (unsigned 8-bit int, 1 byte) SSR Solution ID. + * @field tile_set_id number (unsigned 16-bit int, 2 bytes) Unique identifier of the set this tile belongs to. + * @field tile_id number (unsigned 16-bit int, 2 bytes) Unique identifier of this tile in the tile set. + * @field chain_id number (unsigned 8-bit int, 1 byte) Chain and type of flag. + * @field use_gps_sat number (unsigned 8-bit int, 1 byte) Use GPS satellites. + * @field use_gal_sat number (unsigned 8-bit int, 1 byte) Use GAL satellites. + * @field use_bds_sat number (unsigned 8-bit int, 1 byte) Use BDS satellites. + * @field use_qzss_sat number (unsigned 8-bit int, 1 byte) Use QZSS satellites. + * @field reserved array Reserved + * @field use_tropo_grid_points number (unsigned 8-bit int, 1 byte) Use tropo grid points. + * @field use_iono_grid_points number (unsigned 8-bit int, 1 byte) Use iono grid points. + * @field use_iono_tile_sat_los number (unsigned 8-bit int, 1 byte) Use iono tile satellite LoS. + * @field use_iono_grid_point_sat_los number (unsigned 8-bit int, 1 byte) Use iono grid point satellite LoS. + * + * @param sbp An SBP object with a payload to be decoded. + */ +let MsgSsrFlagHighLevelDepA = function (sbp, fields) { + SBP.call(this, sbp); + this.messageType = "MSG_SSR_FLAG_HIGH_LEVEL_DEP_A"; + this.fields = (fields || this.parser.parse(sbp.payload)); + + return this; +}; +MsgSsrFlagHighLevelDepA.prototype = Object.create(SBP.prototype); +MsgSsrFlagHighLevelDepA.prototype.messageType = "MSG_SSR_FLAG_HIGH_LEVEL_DEP_A"; +MsgSsrFlagHighLevelDepA.prototype.msg_type = 0x0BB9; +MsgSsrFlagHighLevelDepA.prototype.constructor = MsgSsrFlagHighLevelDepA; +MsgSsrFlagHighLevelDepA.prototype.parser = new Parser() + .endianess('little') + .nest('obs_time', { type: GPSTimeSec.prototype.parser }) + .nest('corr_time', { type: GPSTimeSec.prototype.parser }) + .uint8('ssr_sol_id') + .uint16('tile_set_id') + .uint16('tile_id') + .uint8('chain_id') + .uint8('use_gps_sat') + .uint8('use_gal_sat') + .uint8('use_bds_sat') + .uint8('use_qzss_sat') + .array('reserved', { length: 5, type: 'uint8' }) + .uint8('use_tropo_grid_points') + .uint8('use_iono_grid_points') + .uint8('use_iono_tile_sat_los') + .uint8('use_iono_grid_point_sat_los'); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec = []; +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['obs_time', GPSTimeSec.prototype.fieldSpec]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['corr_time', GPSTimeSec.prototype.fieldSpec]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['ssr_sol_id', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['tile_set_id', 'writeUInt16LE', 2]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['tile_id', 'writeUInt16LE', 2]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['chain_id', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_gps_sat', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_gal_sat', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_bds_sat', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_qzss_sat', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['reserved', 'array', 'writeUInt8', function () { return 1; }, 5]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_tropo_grid_points', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_iono_grid_points', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_iono_tile_sat_los', 'writeUInt8', 1]); +MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_iono_grid_point_sat_los', 'writeUInt8', 1]); + +/** + * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BBA). * * Integrity monitoring flags for multiple aggregated elements. An element could be * a satellite, SSR grid point, or SSR tile. A group of aggregated elements being @@ -93,7 +162,8 @@ IntegritySSRHeader.prototype.fieldSpec.push(['chain_id', 'writeUInt8', 1]); * * Fields in the SBP payload (`sbp.payload`): * @field obs_time GPSTimeSec GNSS reference time of the observation used to generate the flag. - * @field corr_time GPSTimeSec GNSS reference time of the correction associated to the flag. + * @field atmo_corr_time GPSTimeSec GNSS reference time of the atmospheric correction associated to the flag. + * @field sat_corr_time GPSTimeSec GNSS reference time of the satellite correction associated to the flag. * @field ssr_sol_id number (unsigned 8-bit int, 1 byte) SSR Solution ID. * @field tile_set_id number (unsigned 16-bit int, 2 bytes) Unique identifier of the set this tile belongs to. * @field tile_id number (unsigned 16-bit int, 2 bytes) Unique identifier of this tile in the tile set. @@ -119,12 +189,13 @@ let MsgSsrFlagHighLevel = function (sbp, fields) { }; MsgSsrFlagHighLevel.prototype = Object.create(SBP.prototype); MsgSsrFlagHighLevel.prototype.messageType = "MSG_SSR_FLAG_HIGH_LEVEL"; -MsgSsrFlagHighLevel.prototype.msg_type = 0x0BB9; +MsgSsrFlagHighLevel.prototype.msg_type = 0x0BBA; MsgSsrFlagHighLevel.prototype.constructor = MsgSsrFlagHighLevel; MsgSsrFlagHighLevel.prototype.parser = new Parser() .endianess('little') .nest('obs_time', { type: GPSTimeSec.prototype.parser }) - .nest('corr_time', { type: GPSTimeSec.prototype.parser }) + .nest('atmo_corr_time', { type: GPSTimeSec.prototype.parser }) + .nest('sat_corr_time', { type: GPSTimeSec.prototype.parser }) .uint8('ssr_sol_id') .uint16('tile_set_id') .uint16('tile_id') @@ -140,7 +211,8 @@ MsgSsrFlagHighLevel.prototype.parser = new Parser() .uint8('use_iono_grid_point_sat_los'); MsgSsrFlagHighLevel.prototype.fieldSpec = []; MsgSsrFlagHighLevel.prototype.fieldSpec.push(['obs_time', GPSTimeSec.prototype.fieldSpec]); -MsgSsrFlagHighLevel.prototype.fieldSpec.push(['corr_time', GPSTimeSec.prototype.fieldSpec]); +MsgSsrFlagHighLevel.prototype.fieldSpec.push(['atmo_corr_time', GPSTimeSec.prototype.fieldSpec]); +MsgSsrFlagHighLevel.prototype.fieldSpec.push(['sat_corr_time', GPSTimeSec.prototype.fieldSpec]); MsgSsrFlagHighLevel.prototype.fieldSpec.push(['ssr_sol_id', 'writeUInt8', 1]); MsgSsrFlagHighLevel.prototype.fieldSpec.push(['tile_set_id', 'writeUInt16LE', 2]); MsgSsrFlagHighLevel.prototype.fieldSpec.push(['tile_id', 'writeUInt16LE', 2]); @@ -379,7 +451,9 @@ MsgAcknowledge.prototype.fieldSpec.push(['solution_id', 'writeUInt8', 1]); module.exports = { IntegritySSRHeader: IntegritySSRHeader, - 0x0BB9: MsgSsrFlagHighLevel, + 0x0BB9: MsgSsrFlagHighLevelDepA, + MsgSsrFlagHighLevelDepA: MsgSsrFlagHighLevelDepA, + 0x0BBA: MsgSsrFlagHighLevel, MsgSsrFlagHighLevel: MsgSsrFlagHighLevel, 0x0BBD: MsgSsrFlagSatellites, MsgSsrFlagSatellites: MsgSsrFlagSatellites, diff --git a/jsonschema/MsgSsrFlagHighLevel.json b/jsonschema/MsgSsrFlagHighLevel.json index 70005ae4a..31bf98024 100644 --- a/jsonschema/MsgSsrFlagHighLevel.json +++ b/jsonschema/MsgSsrFlagHighLevel.json @@ -17,7 +17,8 @@ "type": "object", "properties": { "obs_time": {"$ref": "GpsTimeSec.json"}, - "corr_time": {"$ref": "GpsTimeSec.json"}, + "atmo_corr_time": {"$ref": "GpsTimeSec.json"}, + "sat_corr_time": {"$ref": "GpsTimeSec.json"}, "ssr_sol_id": {"type": "integer"}, "tile_set_id": {"type": "integer"}, "tile_id": {"type": "integer"}, @@ -33,7 +34,8 @@ }, "required": [ "obs_time", - "corr_time", + "atmo_corr_time", + "sat_corr_time", "ssr_sol_id", "tile_set_id", "tile_id", diff --git a/kaitai/ksy/integrity.ksy b/kaitai/ksy/integrity.ksy index bb34cfda7..0d713b832 100644 --- a/kaitai/ksy/integrity.ksy +++ b/kaitai/ksy/integrity.ksy @@ -51,6 +51,73 @@ types: Chain and type of flag. type: u1 + msg_ssr_flag_high_level_dep_a: + doc: | + Deprecated. + seq: + - id: obs_time + doc: | + GNSS reference time of the observation used to generate the flag. + type: gnss::gps_time_sec + - id: corr_time + doc: | + GNSS reference time of the correction associated to the flag. + type: gnss::gps_time_sec + - id: ssr_sol_id + doc: | + SSR Solution ID. + type: u1 + - id: tile_set_id + doc: | + Unique identifier of the set this tile belongs to. + type: u2 + - id: tile_id + doc: | + Unique identifier of this tile in the tile set. + type: u2 + - id: chain_id + doc: | + Chain and type of flag. + type: u1 + - id: use_gps_sat + doc: | + Use GPS satellites. + type: u1 + - id: use_gal_sat + doc: | + Use GAL satellites. + type: u1 + - id: use_bds_sat + doc: | + Use BDS satellites. + type: u1 + - id: use_qzss_sat + doc: | + Use QZSS satellites. + type: u1 + - id: reserved + doc: | + Reserved + type: u1 + repeat: expr + repeat-expr: 5 + - id: use_tropo_grid_points + doc: | + Use tropo grid points. + type: u1 + - id: use_iono_grid_points + doc: | + Use iono grid points. + type: u1 + - id: use_iono_tile_sat_los + doc: | + Use iono tile satellite LoS. + type: u1 + - id: use_iono_grid_point_sat_los + doc: | + Use iono grid point satellite LoS. + type: u1 + msg_ssr_flag_high_level: doc: | Integrity monitoring flags for multiple aggregated elements. An element @@ -83,9 +150,15 @@ types: doc: | GNSS reference time of the observation used to generate the flag. type: gnss::gps_time_sec - - id: corr_time + - id: atmo_corr_time doc: | - GNSS reference time of the correction associated to the flag. + GNSS reference time of the atmospheric correction associated to the + flag. + type: gnss::gps_time_sec + - id: sat_corr_time + doc: | + GNSS reference time of the satellite correction associated to the + flag. type: gnss::gps_time_sec - id: ssr_sol_id doc: | diff --git a/kaitai/ksy/sbp.ksy b/kaitai/ksy/sbp.ksy index 870563ca5..846496fb3 100644 --- a/kaitai/ksy/sbp.ksy +++ b/kaitai/ksy/sbp.ksy @@ -97,7 +97,8 @@ enums: 2305: msg_imu_aux 2309: msg_imu_comp - 3001: msg_ssr_flag_high_level + 3001: msg_ssr_flag_high_level_dep_a + 3002: msg_ssr_flag_high_level 3005: msg_ssr_flag_satellites 3011: msg_ssr_flag_tropo_grid_points 3015: msg_ssr_flag_iono_grid_points @@ -381,7 +382,8 @@ types: 2305: imu::msg_imu_aux 2309: imu::msg_imu_comp - 3001: integrity::msg_ssr_flag_high_level + 3001: integrity::msg_ssr_flag_high_level_dep_a + 3002: integrity::msg_ssr_flag_high_level 3005: integrity::msg_ssr_flag_satellites 3011: integrity::msg_ssr_flag_tropo_grid_points 3015: integrity::msg_ssr_flag_iono_grid_points diff --git a/kaitai/perl/KaitaiSbp/Integrity.pm b/kaitai/perl/KaitaiSbp/Integrity.pm index a522c9bce..a842bf1be 100644 --- a/kaitai/perl/KaitaiSbp/Integrity.pm +++ b/kaitai/perl/KaitaiSbp/Integrity.pm @@ -481,7 +481,7 @@ sub faulty_points { } ######################################################################## -package Integrity::MsgSsrFlagHighLevel; +package Integrity::MsgSsrFlagHighLevelDepA; our @ISA = 'IO::KaitaiStruct::Struct'; @@ -606,4 +606,136 @@ sub use_iono_grid_point_sat_los { return $self->{use_iono_grid_point_sat_los}; } +######################################################################## +package Integrity::MsgSsrFlagHighLevel; + +our @ISA = 'IO::KaitaiStruct::Struct'; + +sub from_file { + my ($class, $filename) = @_; + my $fd; + + open($fd, '<', $filename) or return undef; + binmode($fd); + return new($class, IO::KaitaiStruct::Stream->new($fd)); +} + +sub new { + my ($class, $_io, $_parent, $_root) = @_; + my $self = IO::KaitaiStruct::Struct->new($_io); + + bless $self, $class; + $self->{_parent} = $_parent; + $self->{_root} = $_root || $self;; + + $self->_read(); + + return $self; +} + +sub _read { + my ($self) = @_; + + $self->{obs_time} = Gnss::GpsTimeSec->new($self->{_io}, $self, $self->{_root}); + $self->{atmo_corr_time} = Gnss::GpsTimeSec->new($self->{_io}, $self, $self->{_root}); + $self->{sat_corr_time} = Gnss::GpsTimeSec->new($self->{_io}, $self, $self->{_root}); + $self->{ssr_sol_id} = $self->{_io}->read_u1(); + $self->{tile_set_id} = $self->{_io}->read_u2le(); + $self->{tile_id} = $self->{_io}->read_u2le(); + $self->{chain_id} = $self->{_io}->read_u1(); + $self->{use_gps_sat} = $self->{_io}->read_u1(); + $self->{use_gal_sat} = $self->{_io}->read_u1(); + $self->{use_bds_sat} = $self->{_io}->read_u1(); + $self->{use_qzss_sat} = $self->{_io}->read_u1(); + $self->{reserved} = []; + my $n_reserved = 5; + for (my $i = 0; $i < $n_reserved; $i++) { + push @{$self->{reserved}}, $self->{_io}->read_u1(); + } + $self->{use_tropo_grid_points} = $self->{_io}->read_u1(); + $self->{use_iono_grid_points} = $self->{_io}->read_u1(); + $self->{use_iono_tile_sat_los} = $self->{_io}->read_u1(); + $self->{use_iono_grid_point_sat_los} = $self->{_io}->read_u1(); +} + +sub obs_time { + my ($self) = @_; + return $self->{obs_time}; +} + +sub atmo_corr_time { + my ($self) = @_; + return $self->{atmo_corr_time}; +} + +sub sat_corr_time { + my ($self) = @_; + return $self->{sat_corr_time}; +} + +sub ssr_sol_id { + my ($self) = @_; + return $self->{ssr_sol_id}; +} + +sub tile_set_id { + my ($self) = @_; + return $self->{tile_set_id}; +} + +sub tile_id { + my ($self) = @_; + return $self->{tile_id}; +} + +sub chain_id { + my ($self) = @_; + return $self->{chain_id}; +} + +sub use_gps_sat { + my ($self) = @_; + return $self->{use_gps_sat}; +} + +sub use_gal_sat { + my ($self) = @_; + return $self->{use_gal_sat}; +} + +sub use_bds_sat { + my ($self) = @_; + return $self->{use_bds_sat}; +} + +sub use_qzss_sat { + my ($self) = @_; + return $self->{use_qzss_sat}; +} + +sub reserved { + my ($self) = @_; + return $self->{reserved}; +} + +sub use_tropo_grid_points { + my ($self) = @_; + return $self->{use_tropo_grid_points}; +} + +sub use_iono_grid_points { + my ($self) = @_; + return $self->{use_iono_grid_points}; +} + +sub use_iono_tile_sat_los { + my ($self) = @_; + return $self->{use_iono_tile_sat_los}; +} + +sub use_iono_grid_point_sat_los { + my ($self) = @_; + return $self->{use_iono_grid_point_sat_los}; +} + 1; diff --git a/kaitai/perl/KaitaiSbp/Sbp.pm b/kaitai/perl/KaitaiSbp/Sbp.pm index 0f3f1be21..980f6db29 100644 --- a/kaitai/perl/KaitaiSbp/Sbp.pm +++ b/kaitai/perl/KaitaiSbp/Sbp.pm @@ -234,7 +234,8 @@ our $MSG_IDS_MSG_MAG_RAW = 2306; our $MSG_IDS_MSG_ODOMETRY = 2307; our $MSG_IDS_MSG_WHEELTICK = 2308; our $MSG_IDS_MSG_IMU_COMP = 2309; -our $MSG_IDS_MSG_SSR_FLAG_HIGH_LEVEL = 3001; +our $MSG_IDS_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A = 3001; +our $MSG_IDS_MSG_SSR_FLAG_HIGH_LEVEL = 3002; our $MSG_IDS_MSG_SSR_FLAG_SATELLITES = 3005; our $MSG_IDS_MSG_SSR_FLAG_TROPO_GRID_POINTS = 3011; our $MSG_IDS_MSG_SSR_FLAG_IONO_GRID_POINTS = 3015; @@ -1510,7 +1511,7 @@ sub _read { elsif ($_on == 3001) { $self->{_raw_payload} = $self->{_io}->read_bytes($self->length()); my $io__raw_payload = IO::KaitaiStruct::Stream->new($self->{_raw_payload}); - $self->{payload} = Integrity::MsgSsrFlagHighLevel->new($io__raw_payload, $self, $self->{_root}); + $self->{payload} = Integrity::MsgSsrFlagHighLevelDepA->new($io__raw_payload, $self, $self->{_root}); } elsif ($_on == 30) { $self->{_raw_payload} = $self->{_io}->read_bytes($self->length()); @@ -1542,6 +1543,11 @@ sub _read { my $io__raw_payload = IO::KaitaiStruct::Stream->new($self->{_raw_payload}); $self->{payload} = Bootload::MsgNapDeviceDnaReq->new($io__raw_payload, $self, $self->{_root}); } + elsif ($_on == 3002) { + $self->{_raw_payload} = $self->{_io}->read_bytes($self->length()); + my $io__raw_payload = IO::KaitaiStruct::Stream->new($self->{_raw_payload}); + $self->{payload} = Integrity::MsgSsrFlagHighLevel->new($io__raw_payload, $self, $self->{_root}); + } else { $self->{payload} = $self->{_io}->read_bytes($self->length()); } diff --git a/kaitai/perl/KaitaiSbp/Table.pm b/kaitai/perl/KaitaiSbp/Table.pm index 2f69d8e28..5f12a5de4 100644 --- a/kaitai/perl/KaitaiSbp/Table.pm +++ b/kaitai/perl/KaitaiSbp/Table.pm @@ -91,7 +91,8 @@ our %TABLE = ( 2305 => sub{Imu::MsgImuAux->new(@_)}, 2309 => sub{Imu::MsgImuComp->new(@_)}, - 3001 => sub{Integrity::MsgSsrFlagHighLevel->new(@_)}, + 3001 => sub{Integrity::MsgSsrFlagHighLevelDepA->new(@_)}, + 3002 => sub{Integrity::MsgSsrFlagHighLevel->new(@_)}, 3005 => sub{Integrity::MsgSsrFlagSatellites->new(@_)}, 3011 => sub{Integrity::MsgSsrFlagTropoGridPoints->new(@_)}, 3015 => sub{Integrity::MsgSsrFlagIonoGridPoints->new(@_)}, diff --git a/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevel.t b/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevel.t index 2e66aa82d..d36470c81 100644 --- a/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevel.t +++ b/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevel.t @@ -35,26 +35,28 @@ sub test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1() { is($msg->{'preamble'}, 0x55, "preamble"); - is($msg->{'msg_type'}, 0x0BB9, "msg_type"); + is($msg->{'msg_type'}, 0x0BBA, "msg_type"); is($msg->{'sender'}, 0x0042, "sender"); is($msg->{'length'}, 31, "length"); - is($msg->{'payload'}, "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "payload"); + is($msg->{'payload'}, "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "payload"); - is($msg->{'crc'}, 0x0369, "crc"); + is($msg->{'crc'}, 0xBE9D, "crc"); my $json = JSON::PP->new->convert_blessed->canonical; - is($msg->chain_id(), 40, "chain_id"); + is($json->encode($msg->atmo_corr_time()), $json->encode($json->decode(q{{"tow":365,"wn":6}})), "atmo_corr_time"); - is($json->encode($msg->corr_time()), $json->encode($json->decode(q{{"tow":360,"wn":6}})), "corr_time"); + is($msg->chain_id(), 40, "chain_id"); is($json->encode($msg->obs_time()), $json->encode($json->decode(q{{"tow":180,"wn":3}})), "obs_time"); is($json->encode($msg->reserved()), $json->encode($json->decode(q{[0,0,0,0,0]})), "reserved"); + is($json->encode($msg->sat_corr_time()), $json->encode($json->decode(q{{"tow":360,"wn":6}})), "sat_corr_time"); + is($msg->ssr_sol_id(), 10, "ssr_sol_id"); is($msg->tile_id(), 30, "tile_id"); @@ -77,7 +79,7 @@ sub test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1() { is($msg->use_tropo_grid_points(), 5, "use_tropo_grid_points"); - is($json->encode($msg), $json->encode($json->decode(q{{"chain_id":40,"corr_time":{"tow":360,"wn":6},"crc":873,"length":31,"msg_type":3001,"obs_time":{"tow":180,"wn":3},"payload":"tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==","preamble":85,"reserved":[0,0,0,0,0],"sender":66,"ssr_sol_id":10,"tile_id":30,"tile_set_id":20,"use_bds_sat":3,"use_gal_sat":2,"use_gps_sat":1,"use_iono_grid_point_sat_los":8,"use_iono_grid_points":6,"use_iono_tile_sat_los":7,"use_qzss_sat":4,"use_tropo_grid_points":5}})), "raw_json"); + is($json->encode($msg), $json->encode($json->decode(q{{"atmo_corr_time":{"tow":365,"wn":6},"chain_id":40,"crc":48797,"length":31,"msg_type":3001,"obs_time":{"tow":180,"wn":3},"payload":"tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==","preamble":85,"reserved":[0,0,0,0,0],"sat_corr_time":{"tow":360,"wn":6},"sender":66,"ssr_sol_id":10,"tile_id":30,"tile_set_id":20,"use_bds_sat":3,"use_gal_sat":2,"use_gps_sat":1,"use_iono_grid_point_sat_los":8,"use_iono_grid_points":6,"use_iono_tile_sat_los":7,"use_qzss_sat":4,"use_tropo_grid_points":5}})), "raw_json"); } test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1(); diff --git a/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.t b/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.t new file mode 100644 index 000000000..c0eeddbbb --- /dev/null +++ b/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.t @@ -0,0 +1,84 @@ +#!/usr/bin/perl -w +# +# Copyright (C) 2015-2023 Swift Navigation Inc. +# Contact: https://support.swiftnav.com +# +# This source is subject to the license found in the file 'LICENSE' which must +# be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. +# +# Test cases automatically generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml +# with generate.py. Do not modify by hand! + +use strict; + +BEGIN { + # add grandparent directory to include path + use Cwd qw(realpath); + use File::Basename; + unshift @INC, realpath(dirname($0))."/../../"; +} + +use KaitaiSbp::Sbp; +use KaitaiSbp::ParseUtils; +use IO::KaitaiStruct; +use Test::More; +use JSON::PP; +use MIME::Base64; +sub test_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a_1() { + my $buf = decode_base64("VbkLQgAftAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCGkD"); + my $stream = IO::KaitaiStruct::Stream->new($buf); + my $msg = ParseUtils::get_flattened_msg(Sbp::SbpMessage->new($stream)); + + is($msg->{'preamble'}, 0x55, "preamble"); + + is($msg->{'msg_type'}, 0x0BB9, "msg_type"); + + is($msg->{'sender'}, 0x0042, "sender"); + + is($msg->{'length'}, 31, "length"); + + is($msg->{'payload'}, "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "payload"); + + is($msg->{'crc'}, 0x0369, "crc"); + + my $json = JSON::PP->new->convert_blessed->canonical; + + is($msg->chain_id(), 40, "chain_id"); + + is($json->encode($msg->corr_time()), $json->encode($json->decode(q{{"tow":360,"wn":6}})), "corr_time"); + + is($json->encode($msg->obs_time()), $json->encode($json->decode(q{{"tow":180,"wn":3}})), "obs_time"); + + is($json->encode($msg->reserved()), $json->encode($json->decode(q{[0,0,0,0,0]})), "reserved"); + + is($msg->ssr_sol_id(), 10, "ssr_sol_id"); + + is($msg->tile_id(), 30, "tile_id"); + + is($msg->tile_set_id(), 20, "tile_set_id"); + + is($msg->use_bds_sat(), 3, "use_bds_sat"); + + is($msg->use_gal_sat(), 2, "use_gal_sat"); + + is($msg->use_gps_sat(), 1, "use_gps_sat"); + + is($msg->use_iono_grid_point_sat_los(), 8, "use_iono_grid_point_sat_los"); + + is($msg->use_iono_grid_points(), 6, "use_iono_grid_points"); + + is($msg->use_iono_tile_sat_los(), 7, "use_iono_tile_sat_los"); + + is($msg->use_qzss_sat(), 4, "use_qzss_sat"); + + is($msg->use_tropo_grid_points(), 5, "use_tropo_grid_points"); + + is($json->encode($msg), $json->encode($json->decode(q{{"chain_id":40,"corr_time":{"tow":360,"wn":6},"crc":873,"length":31,"msg_type":3001,"obs_time":{"tow":180,"wn":3},"payload":"tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==","preamble":85,"reserved":[0,0,0,0,0],"sender":66,"ssr_sol_id":10,"tile_id":30,"tile_set_id":20,"use_bds_sat":3,"use_gal_sat":2,"use_gps_sat":1,"use_iono_grid_point_sat_los":8,"use_iono_grid_points":6,"use_iono_tile_sat_los":7,"use_qzss_sat":4,"use_tropo_grid_points":5}})), "raw_json"); +} +test_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a_1(); + +done_testing(); diff --git a/kaitai/python/kaitai_sbp/integrity.py b/kaitai/python/kaitai_sbp/integrity.py index 7fcf216f6..049a0ced1 100644 --- a/kaitai/python/kaitai_sbp/integrity.py +++ b/kaitai/python/kaitai_sbp/integrity.py @@ -147,6 +147,36 @@ def _read(self): + class MsgSsrFlagHighLevelDepA(KaitaiStruct): + """Deprecated. + """ + def __init__(self, _io, _parent=None, _root=None): + self._io = _io + self._parent = _parent + self._root = _root if _root else self + self._read() + + def _read(self): + self.obs_time = Gnss.GpsTimeSec(self._io, self, self._root) + self.corr_time = Gnss.GpsTimeSec(self._io, self, self._root) + self.ssr_sol_id = self._io.read_u1() + self.tile_set_id = self._io.read_u2le() + self.tile_id = self._io.read_u2le() + self.chain_id = self._io.read_u1() + self.use_gps_sat = self._io.read_u1() + self.use_gal_sat = self._io.read_u1() + self.use_bds_sat = self._io.read_u1() + self.use_qzss_sat = self._io.read_u1() + self.reserved = [] + for i in range(5): + self.reserved.append(self._io.read_u1()) + + self.use_tropo_grid_points = self._io.read_u1() + self.use_iono_grid_points = self._io.read_u1() + self.use_iono_tile_sat_los = self._io.read_u1() + self.use_iono_grid_point_sat_los = self._io.read_u1() + + class MsgSsrFlagHighLevel(KaitaiStruct): """Integrity monitoring flags for multiple aggregated elements. An element could be a satellite, SSR grid point, or SSR tile. A group of aggregated @@ -182,7 +212,8 @@ def __init__(self, _io, _parent=None, _root=None): def _read(self): self.obs_time = Gnss.GpsTimeSec(self._io, self, self._root) - self.corr_time = Gnss.GpsTimeSec(self._io, self, self._root) + self.atmo_corr_time = Gnss.GpsTimeSec(self._io, self, self._root) + self.sat_corr_time = Gnss.GpsTimeSec(self._io, self, self._root) self.ssr_sol_id = self._io.read_u1() self.tile_set_id = self._io.read_u2le() self.tile_id = self._io.read_u2le() diff --git a/kaitai/python/kaitai_sbp/sbp.py b/kaitai/python/kaitai_sbp/sbp.py index 75d6ae8b8..5b7f5627f 100644 --- a/kaitai/python/kaitai_sbp/sbp.py +++ b/kaitai/python/kaitai_sbp/sbp.py @@ -227,7 +227,8 @@ class MsgIds(Enum): msg_odometry = 2307 msg_wheeltick = 2308 msg_imu_comp = 2309 - msg_ssr_flag_high_level = 3001 + msg_ssr_flag_high_level_dep_a = 3001 + msg_ssr_flag_high_level = 3002 msg_ssr_flag_satellites = 3005 msg_ssr_flag_tropo_grid_points = 3011 msg_ssr_flag_iono_grid_points = 3015 @@ -1237,7 +1238,7 @@ def _read(self): elif _on == 3001: self._raw_payload = self._io.read_bytes(self.length) _io__raw_payload = KaitaiStream(BytesIO(self._raw_payload)) - self.payload = Integrity.MsgSsrFlagHighLevel(_io__raw_payload, self, self._root) + self.payload = Integrity.MsgSsrFlagHighLevelDepA(_io__raw_payload, self, self._root) elif _on == 30: self._raw_payload = self._io.read_bytes(self.length) _io__raw_payload = KaitaiStream(BytesIO(self._raw_payload)) @@ -1262,6 +1263,10 @@ def _read(self): self._raw_payload = self._io.read_bytes(self.length) _io__raw_payload = KaitaiStream(BytesIO(self._raw_payload)) self.payload = Bootload.MsgNapDeviceDnaReq(_io__raw_payload, self, self._root) + elif _on == 3002: + self._raw_payload = self._io.read_bytes(self.length) + _io__raw_payload = KaitaiStream(BytesIO(self._raw_payload)) + self.payload = Integrity.MsgSsrFlagHighLevel(_io__raw_payload, self, self._root) else: self.payload = self._io.read_bytes(self.length) self.crc = self._io.read_u2le() diff --git a/kaitai/python/kaitai_sbp/table.py b/kaitai/python/kaitai_sbp/table.py index 1685d4439..17ab1718a 100644 --- a/kaitai/python/kaitai_sbp/table.py +++ b/kaitai/python/kaitai_sbp/table.py @@ -85,7 +85,8 @@ 2305: Imu.MsgImuAux, 2309: Imu.MsgImuComp, - 3001: Integrity.MsgSsrFlagHighLevel, + 3001: Integrity.MsgSsrFlagHighLevelDepA, + 3002: Integrity.MsgSsrFlagHighLevel, 3005: Integrity.MsgSsrFlagSatellites, 3011: Integrity.MsgSsrFlagTropoGridPoints, 3015: Integrity.MsgSsrFlagIonoGridPoints, diff --git a/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevel.py b/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevel.py index 8a9739e18..f73445127 100644 --- a/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevel.py +++ b/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevel.py @@ -26,24 +26,26 @@ def test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1(): assert msg.preamble == 0x55 - assert msg.msg_type == 0x0BB9 + assert msg.msg_type == 0x0BBA assert msg.sender == 0x0042 assert msg.length == 31 - assert msg.payload == "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==" + assert msg.payload == "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==" - assert msg.crc == 0x0369 + assert msg.crc == 0xBE9D - assert dictify(msg.chain_id) == 40 + assert dictify(msg.atmo_corr_time) == {'tow': 365, 'wn': 6} - assert dictify(msg.corr_time) == {'tow': 360, 'wn': 6} + assert dictify(msg.chain_id) == 40 assert dictify(msg.obs_time) == {'tow': 180, 'wn': 3} assert dictify(msg.reserved) == [0, 0, 0, 0, 0] + assert dictify(msg.sat_corr_time) == {'tow': 360, 'wn': 6} + assert dictify(msg.ssr_sol_id) == 10 assert dictify(msg.tile_id) == 30 @@ -66,4 +68,4 @@ def test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1(): assert dictify(msg.use_tropo_grid_points) == 5 - assert dictify(msg) == {'obs_time': {'tow': 180, 'wn': 3}, 'corr_time': {'tow': 360, 'wn': 6}, 'ssr_sol_id': 10, 'tile_set_id': 20, 'tile_id': 30, 'chain_id': 40, 'use_gps_sat': 1, 'use_gal_sat': 2, 'use_bds_sat': 3, 'use_qzss_sat': 4, 'reserved': [0, 0, 0, 0, 0], 'use_tropo_grid_points': 5, 'use_iono_grid_points': 6, 'use_iono_tile_sat_los': 7, 'use_iono_grid_point_sat_los': 8, 'preamble': 85, 'msg_type': 3001, 'sender': 66, 'length': 31, 'payload': 'tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==', 'crc': 873} + assert dictify(msg) == {'obs_time': {'tow': 180, 'wn': 3}, 'sat_corr_time': {'tow': 360, 'wn': 6}, 'atmo_corr_time': {'tow': 365, 'wn': 6}, 'ssr_sol_id': 10, 'tile_set_id': 20, 'tile_id': 30, 'chain_id': 40, 'use_gps_sat': 1, 'use_gal_sat': 2, 'use_bds_sat': 3, 'use_qzss_sat': 4, 'reserved': [0, 0, 0, 0, 0], 'use_tropo_grid_points': 5, 'use_iono_grid_points': 6, 'use_iono_tile_sat_los': 7, 'use_iono_grid_point_sat_los': 8, 'preamble': 85, 'msg_type': 3001, 'sender': 66, 'length': 31, 'payload': 'tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==', 'crc': 48797} diff --git a/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.py b/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.py new file mode 100644 index 000000000..0c1a6bf54 --- /dev/null +++ b/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevelDepA.py @@ -0,0 +1,69 @@ +# Copyright (C) 2015-2023 Swift Navigation Inc. +# Contact: https://support.swiftnav.com +# +# This source is subject to the license found in the file 'LICENSE' which must +# be distributed together with this source. All other rights reserved. +# +# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. +# +# Test cases automatically generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml +# with generate.py. Do not modify by hand! + +import kaitai_sbp.sbp as sbp +from kaitai_sbp.parse_utils import get_flattened_msg +from kaitai_sbp.tests.utils import dictify +from kaitaistruct import KaitaiStream +import io +import base64 + +def test_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a_1(): + buf = base64.standard_b64decode("VbkLQgAftAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCGkD") + + stream = KaitaiStream(io.BytesIO(buf)) + msg = get_flattened_msg(sbp.Sbp.SbpMessage(stream)) + + assert msg.preamble == 0x55 + + assert msg.msg_type == 0x0BB9 + + assert msg.sender == 0x0042 + + assert msg.length == 31 + + assert msg.payload == "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==" + + assert msg.crc == 0x0369 + + assert dictify(msg.chain_id) == 40 + + assert dictify(msg.corr_time) == {'tow': 360, 'wn': 6} + + assert dictify(msg.obs_time) == {'tow': 180, 'wn': 3} + + assert dictify(msg.reserved) == [0, 0, 0, 0, 0] + + assert dictify(msg.ssr_sol_id) == 10 + + assert dictify(msg.tile_id) == 30 + + assert dictify(msg.tile_set_id) == 20 + + assert dictify(msg.use_bds_sat) == 3 + + assert dictify(msg.use_gal_sat) == 2 + + assert dictify(msg.use_gps_sat) == 1 + + assert dictify(msg.use_iono_grid_point_sat_los) == 8 + + assert dictify(msg.use_iono_grid_points) == 6 + + assert dictify(msg.use_iono_tile_sat_los) == 7 + + assert dictify(msg.use_qzss_sat) == 4 + + assert dictify(msg.use_tropo_grid_points) == 5 + + assert dictify(msg) == {'obs_time': {'tow': 180, 'wn': 3}, 'corr_time': {'tow': 360, 'wn': 6}, 'ssr_sol_id': 10, 'tile_set_id': 20, 'tile_id': 30, 'chain_id': 40, 'use_gps_sat': 1, 'use_gal_sat': 2, 'use_bds_sat': 3, 'use_qzss_sat': 4, 'reserved': [0, 0, 0, 0, 0], 'use_tropo_grid_points': 5, 'use_iono_grid_points': 6, 'use_iono_tile_sat_los': 7, 'use_iono_grid_point_sat_los': 8, 'preamble': 85, 'msg_type': 3001, 'sender': 66, 'length': 31, 'payload': 'tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==', 'crc': 873} diff --git a/proto/integrity.proto b/proto/integrity.proto index 507a8b82f..39fb6df38 100644 --- a/proto/integrity.proto +++ b/proto/integrity.proto @@ -65,19 +65,20 @@ message IntegritySSRHeader { */ message MsgSsrFlagHighLevel { gnss.GpsTimeSec obs_time = 1; - gnss.GpsTimeSec corr_time = 2; - uint32 ssr_sol_id = 3; - uint32 tile_set_id = 4; - uint32 tile_id = 5; - uint32 chain_id = 6; - uint32 use_gps_sat = 7; - uint32 use_gal_sat = 8; - uint32 use_bds_sat = 9; - uint32 use_qzss_sat = 10; - uint32 use_tropo_grid_points = 12; - uint32 use_iono_grid_points = 13; - uint32 use_iono_tile_sat_los = 14; - uint32 use_iono_grid_point_sat_los = 15; + gnss.GpsTimeSec atmo_corr_time = 2; + gnss.GpsTimeSec sat_corr_time = 3; + uint32 ssr_sol_id = 4; + uint32 tile_set_id = 5; + uint32 tile_id = 6; + uint32 chain_id = 7; + uint32 use_gps_sat = 8; + uint32 use_gal_sat = 9; + uint32 use_bds_sat = 10; + uint32 use_qzss_sat = 11; + uint32 use_tropo_grid_points = 13; + uint32 use_iono_grid_points = 14; + uint32 use_iono_tile_sat_los = 15; + uint32 use_iono_grid_point_sat_los = 16; } /** List of satellites which are faulty, per constellation diff --git a/python/sbp/integrity.py b/python/sbp/integrity.py index 47983388d..cf1f22616 100644 --- a/python/sbp/integrity.py +++ b/python/sbp/integrity.py @@ -86,9 +86,174 @@ def from_binary(self, d): for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) -SBP_MSG_SSR_FLAG_HIGH_LEVEL = 0x0BB9 +SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A = 0x0BB9 +class MsgSsrFlagHighLevelDepA(SBP): + """SBP class for message MSG_SSR_FLAG_HIGH_LEVEL_DEP_A (0x0BB9). + + You can have MSG_SSR_FLAG_HIGH_LEVEL_DEP_A inherit its fields directly + from an inherited SBP object, or construct it inline using a dict + of its fields. + + + Deprecated. + + Parameters + ---------- + sbp : SBP + SBP parent object to inherit from. + obs_time : GPSTimeSec + GNSS reference time of the observation used to generate the flag. + corr_time : GPSTimeSec + GNSS reference time of the correction associated to the flag. + ssr_sol_id : int + SSR Solution ID. + tile_set_id : int + Unique identifier of the set this tile belongs to. + tile_id : int + Unique identifier of this tile in the tile set. + chain_id : int + Chain and type of flag. + use_gps_sat : int + Use GPS satellites. + use_gal_sat : int + Use GAL satellites. + use_bds_sat : int + Use BDS satellites. + use_qzss_sat : int + Use QZSS satellites. + reserved : array + Reserved + use_tropo_grid_points : int + Use tropo grid points. + use_iono_grid_points : int + Use iono grid points. + use_iono_tile_sat_los : int + Use iono tile satellite LoS. + use_iono_grid_point_sat_los : int + Use iono grid point satellite LoS. + sender : int + Optional sender ID, defaults to SENDER_ID (see sbp/msg.py). + + """ + _parser = construct.Struct( + 'obs_time' / GPSTimeSec._parser, + 'corr_time' / GPSTimeSec._parser, + 'ssr_sol_id' / construct.Int8ul, + 'tile_set_id' / construct.Int16ul, + 'tile_id' / construct.Int16ul, + 'chain_id' / construct.Int8ul, + 'use_gps_sat' / construct.Int8ul, + 'use_gal_sat' / construct.Int8ul, + 'use_bds_sat' / construct.Int8ul, + 'use_qzss_sat' / construct.Int8ul, + 'reserved' / construct.Array(5, construct.Int8ul), + 'use_tropo_grid_points' / construct.Int8ul, + 'use_iono_grid_points' / construct.Int8ul, + 'use_iono_tile_sat_los' / construct.Int8ul, + 'use_iono_grid_point_sat_los' / construct.Int8ul,) + __slots__ = [ + 'obs_time', + 'corr_time', + 'ssr_sol_id', + 'tile_set_id', + 'tile_id', + 'chain_id', + 'use_gps_sat', + 'use_gal_sat', + 'use_bds_sat', + 'use_qzss_sat', + 'reserved', + 'use_tropo_grid_points', + 'use_iono_grid_points', + 'use_iono_tile_sat_los', + 'use_iono_grid_point_sat_los', + ] + + def __init__(self, sbp=None, **kwargs): + if sbp: + super( MsgSsrFlagHighLevelDepA, + self).__init__(sbp.msg_type, sbp.sender, sbp.length, + sbp.payload, sbp.crc) + self.from_binary(sbp.payload) + else: + super( MsgSsrFlagHighLevelDepA, self).__init__() + self.msg_type = SBP_MSG_SSR_FLAG_HIGH_LEVEL_DEP_A + self.sender = kwargs.pop('sender', SENDER_ID) + self.obs_time = kwargs.pop('obs_time') + self.corr_time = kwargs.pop('corr_time') + self.ssr_sol_id = kwargs.pop('ssr_sol_id') + self.tile_set_id = kwargs.pop('tile_set_id') + self.tile_id = kwargs.pop('tile_id') + self.chain_id = kwargs.pop('chain_id') + self.use_gps_sat = kwargs.pop('use_gps_sat') + self.use_gal_sat = kwargs.pop('use_gal_sat') + self.use_bds_sat = kwargs.pop('use_bds_sat') + self.use_qzss_sat = kwargs.pop('use_qzss_sat') + self.reserved = kwargs.pop('reserved') + self.use_tropo_grid_points = kwargs.pop('use_tropo_grid_points') + self.use_iono_grid_points = kwargs.pop('use_iono_grid_points') + self.use_iono_tile_sat_los = kwargs.pop('use_iono_tile_sat_los') + self.use_iono_grid_point_sat_los = kwargs.pop('use_iono_grid_point_sat_los') + + def __repr__(self): + return fmt_repr(self) + + @staticmethod + def from_json(s): + """Given a JSON-encoded string s, build a message object. + + """ + d = json.loads(s) + return MsgSsrFlagHighLevelDepA.from_json_dict(d) + + @staticmethod + def from_json_dict(d): + sbp = SBP.from_json_dict(d) + return MsgSsrFlagHighLevelDepA(sbp, **d) + + + def from_binary(self, d): + """Given a binary payload d, update the appropriate payload fields of + the message. + + """ + p = MsgSsrFlagHighLevelDepA._parser.parse(d) + for n in self.__class__.__slots__: + setattr(self, n, getattr(p, n)) + + def to_binary(self): + """Produce a framed/packed SBP message. + + """ + c = containerize(exclude_fields(self)) + self.payload = MsgSsrFlagHighLevelDepA._parser.build(c) + return self.pack() + + def friendly_name(self): + """Produces friendly human-readable name for this message + + """ + return "SSR FLAG HIGH LEVEL DEP A" + + def into_buffer(self, buf, offset): + """Produce a framed/packed SBP message into the provided buffer and offset. + + """ + self.payload = containerize(exclude_fields(self)) + self.parser = MsgSsrFlagHighLevelDepA._parser + self.stream_payload.reset(buf, offset) + return self.pack_into(buf, offset, self._build_payload) + + def to_json_dict(self): + self.to_binary() + d = super( MsgSsrFlagHighLevelDepA, self).to_json_dict() + j = walk_json_dict(exclude_fields(self)) + d.update(j) + return d + +SBP_MSG_SSR_FLAG_HIGH_LEVEL = 0x0BBA class MsgSsrFlagHighLevel(SBP): - """SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BB9). + """SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BBA). You can have MSG_SSR_FLAG_HIGH_LEVEL inherit its fields directly from an inherited SBP object, or construct it inline using a dict @@ -127,8 +292,10 @@ class MsgSsrFlagHighLevel(SBP): SBP parent object to inherit from. obs_time : GPSTimeSec GNSS reference time of the observation used to generate the flag. - corr_time : GPSTimeSec - GNSS reference time of the correction associated to the flag. + atmo_corr_time : GPSTimeSec + GNSS reference time of the atmospheric correction associated to the flag. + sat_corr_time : GPSTimeSec + GNSS reference time of the satellite correction associated to the flag. ssr_sol_id : int SSR Solution ID. tile_set_id : int @@ -161,7 +328,8 @@ class MsgSsrFlagHighLevel(SBP): """ _parser = construct.Struct( 'obs_time' / GPSTimeSec._parser, - 'corr_time' / GPSTimeSec._parser, + 'atmo_corr_time' / GPSTimeSec._parser, + 'sat_corr_time' / GPSTimeSec._parser, 'ssr_sol_id' / construct.Int8ul, 'tile_set_id' / construct.Int16ul, 'tile_id' / construct.Int16ul, @@ -177,7 +345,8 @@ class MsgSsrFlagHighLevel(SBP): 'use_iono_grid_point_sat_los' / construct.Int8ul,) __slots__ = [ 'obs_time', - 'corr_time', + 'atmo_corr_time', + 'sat_corr_time', 'ssr_sol_id', 'tile_set_id', 'tile_id', @@ -204,7 +373,8 @@ def __init__(self, sbp=None, **kwargs): self.msg_type = SBP_MSG_SSR_FLAG_HIGH_LEVEL self.sender = kwargs.pop('sender', SENDER_ID) self.obs_time = kwargs.pop('obs_time') - self.corr_time = kwargs.pop('corr_time') + self.atmo_corr_time = kwargs.pop('atmo_corr_time') + self.sat_corr_time = kwargs.pop('sat_corr_time') self.ssr_sol_id = kwargs.pop('ssr_sol_id') self.tile_set_id = kwargs.pop('tile_set_id') self.tile_id = kwargs.pop('tile_id') @@ -949,7 +1119,8 @@ def to_json_dict(self): msg_classes = { - 0x0BB9: MsgSsrFlagHighLevel, + 0x0BB9: MsgSsrFlagHighLevelDepA, + 0x0BBA: MsgSsrFlagHighLevel, 0x0BBD: MsgSsrFlagSatellites, 0x0BC3: MsgSsrFlagTropoGridPoints, 0x0BC7: MsgSsrFlagIonoGridPoints, diff --git a/python/tests/sbp/test_table.py b/python/tests/sbp/test_table.py index 23f36a99d..62ca338f6 100644 --- a/python/tests/sbp/test_table.py +++ b/python/tests/sbp/test_table.py @@ -8,95 +8,105 @@ # EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. -from sbp.msg import SBP -from sbp.table import _SBP_TABLE, dispatch +import warnings + from sbp import acquisition as acq from sbp import bootload as boot +from sbp import ext_events as ext_events from sbp import file_io as file_io from sbp import flash as flash +from sbp import imu as imu +from sbp import integrity as integrity from sbp import linux as linux from sbp import logging as log +from sbp import mag as mag from sbp import navigation as nav +from sbp import ndb as ndb from sbp import observation as obs +from sbp import orientation as orientation from sbp import piksi as piksi +from sbp import profiling as profiling +from sbp import sbas as sbas from sbp import settings as settings +from sbp import signing as signing +from sbp import solution_meta as solmeta +from sbp import ssr as ssr from sbp import system as sys +from sbp import telemetry as telemetry from sbp import tracking as trac from sbp import user as user -from sbp import imu as imu -from sbp import integrity as integrity -from sbp import ext_events as ext_events -from sbp import ndb as ndb -from sbp import mag as mag from sbp import vehicle as vehicle -from sbp import orientation as orientation -from sbp import sbas as sbas -from sbp import ssr as ssr -from sbp import solution_meta as solmeta -from sbp import signing as signing -from sbp import telemetry as telemetry -from sbp import profiling as profiling +from sbp.msg import SBP +from sbp.table import _SBP_TABLE, dispatch -import warnings def test_table_count(): - """ - Test number of available messages to deserialize. + """ + Test number of available messages to deserialize. + + """ + number_of_messages = 240 + assert len(_SBP_TABLE) == number_of_messages - """ - number_of_messages = 239 - assert len(_SBP_TABLE) == number_of_messages def test_table_unqiue_count(): - """ - Test number of messages in packages equals total number of messages. - """ - number_of_messages = (len(acq.msg_classes) - + len(boot.msg_classes) - + len(file_io.msg_classes) - + len(flash.msg_classes) - + len(linux.msg_classes) - + len(log.msg_classes) - + len(nav.msg_classes) - + len(obs.msg_classes) - + len(piksi.msg_classes) - + len(settings.msg_classes) - + len(sys.msg_classes) - + len(trac.msg_classes) - + len(user.msg_classes) - + len(imu.msg_classes) - + len(integrity.msg_classes) - + len(ext_events.msg_classes) - + len(ndb.msg_classes) - + len(mag.msg_classes) - + len(vehicle.msg_classes) - + len(orientation.msg_classes) - + len(sbas.msg_classes) - + len(ssr.msg_classes) - + len(solmeta.msg_classes) - + len(signing.msg_classes) - + len(telemetry.msg_classes) - + len(profiling.msg_classes) - ) - assert len(_SBP_TABLE) == number_of_messages + """ + Test number of messages in packages equals total number of messages. + """ + number_of_messages = ( + len(acq.msg_classes) + + len(boot.msg_classes) + + len(file_io.msg_classes) + + len(flash.msg_classes) + + len(linux.msg_classes) + + len(log.msg_classes) + + len(nav.msg_classes) + + len(obs.msg_classes) + + len(piksi.msg_classes) + + len(settings.msg_classes) + + len(sys.msg_classes) + + len(trac.msg_classes) + + len(user.msg_classes) + + len(imu.msg_classes) + + len(integrity.msg_classes) + + len(ext_events.msg_classes) + + len(ndb.msg_classes) + + len(mag.msg_classes) + + len(vehicle.msg_classes) + + len(orientation.msg_classes) + + len(sbas.msg_classes) + + len(ssr.msg_classes) + + len(solmeta.msg_classes) + + len(signing.msg_classes) + + len(telemetry.msg_classes) + + len(profiling.msg_classes) + ) + assert len(_SBP_TABLE) == number_of_messages + def test_available_messages(): - """ - Simple example with a limited dispatch table. + """ + Simple example with a limited dispatch table. - """ - table = {acq.SBP_MSG_ACQ_RESULT_DEP_A: acq.MsgAcqResultDepA, - log.SBP_MSG_PRINT_DEP: log.MsgPrintDep} - msg = SBP(msg_type=0x15, sender=1219, length=13, - payload=b'\x92$yA\x00\x00\xbcC\x81\xc1\xf9\xc5\x1d') - # TODO (Buro): Replace this message constructor once generated SBP - # can support kwargs for constructor, instead of requiring SBP - # object. - assert dispatch(msg, table) == acq.MsgAcqResultDepA(msg) - msg = SBP(msg_type=0xB0, sender=1219, length=4, payload='v1.2', crc=0xCE01) - with warnings.catch_warnings(record=True) as w: - dispatch(msg, table) - warnings.simplefilter("always") - assert len(w) == 1 - assert issubclass(w[0].category, RuntimeWarning) - assert str(w[0].message).find("No message found for msg_type id 176 for msg*") + """ + table = { + acq.SBP_MSG_ACQ_RESULT_DEP_A: acq.MsgAcqResultDepA, + log.SBP_MSG_PRINT_DEP: log.MsgPrintDep, + } + msg = SBP( + msg_type=0x15, + sender=1219, + length=13, + payload=b"\x92$yA\x00\x00\xbcC\x81\xc1\xf9\xc5\x1d", + ) + # TODO (Buro): Replace this message constructor once generated SBP + # can support kwargs for constructor, instead of requiring SBP + # object. + assert dispatch(msg, table) == acq.MsgAcqResultDepA(msg) + msg = SBP(msg_type=0xB0, sender=1219, length=4, payload="v1.2", crc=0xCE01) + with warnings.catch_warnings(record=True) as w: + dispatch(msg, table) + warnings.simplefilter("always") + assert len(w) == 1 + assert issubclass(w[0].category, RuntimeWarning) + assert str(w[0].message).find("No message found for msg_type id 176 for msg*") diff --git a/rust/sbp/src/messages/integrity.rs b/rust/sbp/src/messages/integrity.rs index ef9322b78..2ec6b8a98 100644 --- a/rust/sbp/src/messages/integrity.rs +++ b/rust/sbp/src/messages/integrity.rs @@ -16,6 +16,7 @@ pub use integrity_ssr_header::IntegritySSRHeader; pub use msg_acknowledge::MsgAcknowledge; pub use msg_ssr_flag_high_level::MsgSsrFlagHighLevel; +pub use msg_ssr_flag_high_level_dep_a::MsgSsrFlagHighLevelDepA; pub use msg_ssr_flag_iono_grid_point_sat_los::MsgSsrFlagIonoGridPointSatLos; pub use msg_ssr_flag_iono_grid_points::MsgSsrFlagIonoGridPoints; pub use msg_ssr_flag_iono_tile_sat_los::MsgSsrFlagIonoTileSatLos; @@ -888,9 +889,13 @@ pub mod msg_ssr_flag_high_level { /// GNSS reference time of the observation used to generate the flag. #[cfg_attr(feature = "serde", serde(rename = "obs_time"))] pub obs_time: GpsTimeSec, - /// GNSS reference time of the correction associated to the flag. - #[cfg_attr(feature = "serde", serde(rename = "corr_time"))] - pub corr_time: GpsTimeSec, + /// GNSS reference time of the atmospheric correction associated to the + /// flag. + #[cfg_attr(feature = "serde", serde(rename = "atmo_corr_time"))] + pub atmo_corr_time: GpsTimeSec, + /// GNSS reference time of the satellite correction associated to the flag. + #[cfg_attr(feature = "serde", serde(rename = "sat_corr_time"))] + pub sat_corr_time: GpsTimeSec, /// SSR Solution ID. #[cfg_attr(feature = "serde", serde(rename = "ssr_sol_id"))] pub ssr_sol_id: u8, @@ -1083,7 +1088,7 @@ pub mod msg_ssr_flag_high_level { } impl ConcreteMessage for MsgSsrFlagHighLevel { - const MESSAGE_TYPE: u16 = 3001; + const MESSAGE_TYPE: u16 = 3002; const MESSAGE_NAME: &'static str = "MSG_SSR_FLAG_HIGH_LEVEL"; } @@ -1129,6 +1134,7 @@ pub mod msg_ssr_flag_high_level { impl WireFormat for MsgSsrFlagHighLevel { const MIN_LEN: usize = ::MIN_LEN + + ::MIN_LEN + ::MIN_LEN + ::MIN_LEN + ::MIN_LEN @@ -1145,7 +1151,8 @@ pub mod msg_ssr_flag_high_level { + ::MIN_LEN; fn len(&self) -> usize { WireFormat::len(&self.obs_time) - + WireFormat::len(&self.corr_time) + + WireFormat::len(&self.atmo_corr_time) + + WireFormat::len(&self.sat_corr_time) + WireFormat::len(&self.ssr_sol_id) + WireFormat::len(&self.tile_set_id) + WireFormat::len(&self.tile_id) @@ -1162,7 +1169,8 @@ pub mod msg_ssr_flag_high_level { } fn write(&self, buf: &mut B) { WireFormat::write(&self.obs_time, buf); - WireFormat::write(&self.corr_time, buf); + WireFormat::write(&self.atmo_corr_time, buf); + WireFormat::write(&self.sat_corr_time, buf); WireFormat::write(&self.ssr_sol_id, buf); WireFormat::write(&self.tile_set_id, buf); WireFormat::write(&self.tile_id, buf); @@ -1179,6 +1187,660 @@ pub mod msg_ssr_flag_high_level { } fn parse_unchecked(buf: &mut B) -> Self { MsgSsrFlagHighLevel { + sender_id: None, + obs_time: WireFormat::parse_unchecked(buf), + atmo_corr_time: WireFormat::parse_unchecked(buf), + sat_corr_time: WireFormat::parse_unchecked(buf), + ssr_sol_id: WireFormat::parse_unchecked(buf), + tile_set_id: WireFormat::parse_unchecked(buf), + tile_id: WireFormat::parse_unchecked(buf), + chain_id: WireFormat::parse_unchecked(buf), + use_gps_sat: WireFormat::parse_unchecked(buf), + use_gal_sat: WireFormat::parse_unchecked(buf), + use_bds_sat: WireFormat::parse_unchecked(buf), + use_qzss_sat: WireFormat::parse_unchecked(buf), + reserved: WireFormat::parse_unchecked(buf), + use_tropo_grid_points: WireFormat::parse_unchecked(buf), + use_iono_grid_points: WireFormat::parse_unchecked(buf), + use_iono_tile_sat_los: WireFormat::parse_unchecked(buf), + use_iono_grid_point_sat_los: WireFormat::parse_unchecked(buf), + } + } + } + + /// Use GPS satellites. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseGpsSatellites { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseGpsSatellites { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseGpsSatellites::Nominal => f.write_str("Nominal"), + UseGpsSatellites::Warning => f.write_str("Warning"), + UseGpsSatellites::Alert => f.write_str("Alert"), + UseGpsSatellites::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseGpsSatellites { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseGpsSatellites::Nominal), + 1 => Ok(UseGpsSatellites::Warning), + 2 => Ok(UseGpsSatellites::Alert), + 3 => Ok(UseGpsSatellites::NotMonitored), + i => Err(i), + } + } + } + + /// Use GAL satellites. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseGalSatellites { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseGalSatellites { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseGalSatellites::Nominal => f.write_str("Nominal"), + UseGalSatellites::Warning => f.write_str("Warning"), + UseGalSatellites::Alert => f.write_str("Alert"), + UseGalSatellites::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseGalSatellites { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseGalSatellites::Nominal), + 1 => Ok(UseGalSatellites::Warning), + 2 => Ok(UseGalSatellites::Alert), + 3 => Ok(UseGalSatellites::NotMonitored), + i => Err(i), + } + } + } + + /// Use BDS satellites. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseBdsSatellites { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseBdsSatellites { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseBdsSatellites::Nominal => f.write_str("Nominal"), + UseBdsSatellites::Warning => f.write_str("Warning"), + UseBdsSatellites::Alert => f.write_str("Alert"), + UseBdsSatellites::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseBdsSatellites { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseBdsSatellites::Nominal), + 1 => Ok(UseBdsSatellites::Warning), + 2 => Ok(UseBdsSatellites::Alert), + 3 => Ok(UseBdsSatellites::NotMonitored), + i => Err(i), + } + } + } + + /// Use QZSS satellites. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseQzssSatellites { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseQzssSatellites { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseQzssSatellites::Nominal => f.write_str("Nominal"), + UseQzssSatellites::Warning => f.write_str("Warning"), + UseQzssSatellites::Alert => f.write_str("Alert"), + UseQzssSatellites::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseQzssSatellites { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseQzssSatellites::Nominal), + 1 => Ok(UseQzssSatellites::Warning), + 2 => Ok(UseQzssSatellites::Alert), + 3 => Ok(UseQzssSatellites::NotMonitored), + i => Err(i), + } + } + } + + /// Use tropo grid points. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseTropoGridPoints { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseTropoGridPoints { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseTropoGridPoints::Nominal => f.write_str("Nominal"), + UseTropoGridPoints::Warning => f.write_str("Warning"), + UseTropoGridPoints::Alert => f.write_str("Alert"), + UseTropoGridPoints::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseTropoGridPoints { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseTropoGridPoints::Nominal), + 1 => Ok(UseTropoGridPoints::Warning), + 2 => Ok(UseTropoGridPoints::Alert), + 3 => Ok(UseTropoGridPoints::NotMonitored), + i => Err(i), + } + } + } + + /// Use iono grid points. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseIonoGridPoints { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseIonoGridPoints { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseIonoGridPoints::Nominal => f.write_str("Nominal"), + UseIonoGridPoints::Warning => f.write_str("Warning"), + UseIonoGridPoints::Alert => f.write_str("Alert"), + UseIonoGridPoints::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseIonoGridPoints { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseIonoGridPoints::Nominal), + 1 => Ok(UseIonoGridPoints::Warning), + 2 => Ok(UseIonoGridPoints::Alert), + 3 => Ok(UseIonoGridPoints::NotMonitored), + i => Err(i), + } + } + } + + /// Use iono tile satellite LoS. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseIonoTileSatelliteLoS { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseIonoTileSatelliteLoS { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseIonoTileSatelliteLoS::Nominal => f.write_str("Nominal"), + UseIonoTileSatelliteLoS::Warning => f.write_str("Warning"), + UseIonoTileSatelliteLoS::Alert => f.write_str("Alert"), + UseIonoTileSatelliteLoS::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseIonoTileSatelliteLoS { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseIonoTileSatelliteLoS::Nominal), + 1 => Ok(UseIonoTileSatelliteLoS::Warning), + 2 => Ok(UseIonoTileSatelliteLoS::Alert), + 3 => Ok(UseIonoTileSatelliteLoS::NotMonitored), + i => Err(i), + } + } + } + + /// Use iono grid point satellite LoS. + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub enum UseIonoGridPointSatelliteLoS { + /// Nominal + Nominal = 0, + + /// Warning + Warning = 1, + + /// Alert + Alert = 2, + + /// Not monitored + NotMonitored = 3, + } + + impl std::fmt::Display for UseIonoGridPointSatelliteLoS { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + UseIonoGridPointSatelliteLoS::Nominal => f.write_str("Nominal"), + UseIonoGridPointSatelliteLoS::Warning => f.write_str("Warning"), + UseIonoGridPointSatelliteLoS::Alert => f.write_str("Alert"), + UseIonoGridPointSatelliteLoS::NotMonitored => f.write_str("Not monitored"), + } + } + } + + impl TryFrom for UseIonoGridPointSatelliteLoS { + type Error = u8; + fn try_from(i: u8) -> Result { + match i { + 0 => Ok(UseIonoGridPointSatelliteLoS::Nominal), + 1 => Ok(UseIonoGridPointSatelliteLoS::Warning), + 2 => Ok(UseIonoGridPointSatelliteLoS::Alert), + 3 => Ok(UseIonoGridPointSatelliteLoS::NotMonitored), + i => Err(i), + } + } + } +} + +pub mod msg_ssr_flag_high_level_dep_a { + #![allow(unused_imports)] + + use super::*; + use crate::messages::gnss::*; + use crate::messages::lib::*; + + /// Deprecated + /// + /// Deprecated. + /// + #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Debug, PartialEq, Clone)] + pub struct MsgSsrFlagHighLevelDepA { + /// The message sender_id + #[cfg_attr(feature = "serde", serde(skip_serializing, alias = "sender"))] + pub sender_id: Option, + /// GNSS reference time of the observation used to generate the flag. + #[cfg_attr(feature = "serde", serde(rename = "obs_time"))] + pub obs_time: GpsTimeSec, + /// GNSS reference time of the correction associated to the flag. + #[cfg_attr(feature = "serde", serde(rename = "corr_time"))] + pub corr_time: GpsTimeSec, + /// SSR Solution ID. + #[cfg_attr(feature = "serde", serde(rename = "ssr_sol_id"))] + pub ssr_sol_id: u8, + /// Unique identifier of the set this tile belongs to. + #[cfg_attr(feature = "serde", serde(rename = "tile_set_id"))] + pub tile_set_id: u16, + /// Unique identifier of this tile in the tile set. + #[cfg_attr(feature = "serde", serde(rename = "tile_id"))] + pub tile_id: u16, + /// Chain and type of flag. + #[cfg_attr(feature = "serde", serde(rename = "chain_id"))] + pub chain_id: u8, + /// Use GPS satellites. + #[cfg_attr(feature = "serde", serde(rename = "use_gps_sat"))] + pub use_gps_sat: u8, + /// Use GAL satellites. + #[cfg_attr(feature = "serde", serde(rename = "use_gal_sat"))] + pub use_gal_sat: u8, + /// Use BDS satellites. + #[cfg_attr(feature = "serde", serde(rename = "use_bds_sat"))] + pub use_bds_sat: u8, + /// Use QZSS satellites. + #[cfg_attr(feature = "serde", serde(rename = "use_qzss_sat"))] + pub use_qzss_sat: u8, + /// Reserved + #[cfg_attr(feature = "serde", serde(rename = "reserved"))] + pub reserved: [u8; 5], + /// Use tropo grid points. + #[cfg_attr(feature = "serde", serde(rename = "use_tropo_grid_points"))] + pub use_tropo_grid_points: u8, + /// Use iono grid points. + #[cfg_attr(feature = "serde", serde(rename = "use_iono_grid_points"))] + pub use_iono_grid_points: u8, + /// Use iono tile satellite LoS. + #[cfg_attr(feature = "serde", serde(rename = "use_iono_tile_sat_los"))] + pub use_iono_tile_sat_los: u8, + /// Use iono grid point satellite LoS. + #[cfg_attr(feature = "serde", serde(rename = "use_iono_grid_point_sat_los"))] + pub use_iono_grid_point_sat_los: u8, + } + + impl MsgSsrFlagHighLevelDepA { + /// Gets the [UseGpsSatellites][self::UseGpsSatellites] stored in the `use_gps_sat` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseGpsSatellites` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseGpsSatellites` were added. + pub fn use_gps_satellites(&self) -> Result { + get_bit_range!(self.use_gps_sat, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseGpsSatellites][UseGpsSatellites] of the `use_gps_sat` bitfield. + pub fn set_use_gps_satellites(&mut self, use_gps_satellites: UseGpsSatellites) { + set_bit_range!(&mut self.use_gps_sat, use_gps_satellites, u8, u8, 2, 0); + } + + /// Gets the [UseGalSatellites][self::UseGalSatellites] stored in the `use_gal_sat` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseGalSatellites` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseGalSatellites` were added. + pub fn use_gal_satellites(&self) -> Result { + get_bit_range!(self.use_gal_sat, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseGalSatellites][UseGalSatellites] of the `use_gal_sat` bitfield. + pub fn set_use_gal_satellites(&mut self, use_gal_satellites: UseGalSatellites) { + set_bit_range!(&mut self.use_gal_sat, use_gal_satellites, u8, u8, 2, 0); + } + + /// Gets the [UseBdsSatellites][self::UseBdsSatellites] stored in the `use_bds_sat` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseBdsSatellites` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseBdsSatellites` were added. + pub fn use_bds_satellites(&self) -> Result { + get_bit_range!(self.use_bds_sat, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseBdsSatellites][UseBdsSatellites] of the `use_bds_sat` bitfield. + pub fn set_use_bds_satellites(&mut self, use_bds_satellites: UseBdsSatellites) { + set_bit_range!(&mut self.use_bds_sat, use_bds_satellites, u8, u8, 2, 0); + } + + /// Gets the [UseQzssSatellites][self::UseQzssSatellites] stored in the `use_qzss_sat` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseQzssSatellites` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseQzssSatellites` were added. + pub fn use_qzss_satellites(&self) -> Result { + get_bit_range!(self.use_qzss_sat, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseQzssSatellites][UseQzssSatellites] of the `use_qzss_sat` bitfield. + pub fn set_use_qzss_satellites(&mut self, use_qzss_satellites: UseQzssSatellites) { + set_bit_range!(&mut self.use_qzss_sat, use_qzss_satellites, u8, u8, 2, 0); + } + + /// Gets the [UseTropoGridPoints][self::UseTropoGridPoints] stored in the `use_tropo_grid_points` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseTropoGridPoints` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseTropoGridPoints` were added. + pub fn use_tropo_grid_points(&self) -> Result { + get_bit_range!(self.use_tropo_grid_points, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseTropoGridPoints][UseTropoGridPoints] of the `use_tropo_grid_points` bitfield. + pub fn set_use_tropo_grid_points(&mut self, use_tropo_grid_points: UseTropoGridPoints) { + set_bit_range!( + &mut self.use_tropo_grid_points, + use_tropo_grid_points, + u8, + u8, + 2, + 0 + ); + } + + /// Gets the [UseIonoGridPoints][self::UseIonoGridPoints] stored in the `use_iono_grid_points` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseIonoGridPoints` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseIonoGridPoints` were added. + pub fn use_iono_grid_points(&self) -> Result { + get_bit_range!(self.use_iono_grid_points, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseIonoGridPoints][UseIonoGridPoints] of the `use_iono_grid_points` bitfield. + pub fn set_use_iono_grid_points(&mut self, use_iono_grid_points: UseIonoGridPoints) { + set_bit_range!( + &mut self.use_iono_grid_points, + use_iono_grid_points, + u8, + u8, + 2, + 0 + ); + } + + /// Gets the [UseIonoTileSatelliteLoS][self::UseIonoTileSatelliteLoS] stored in the `use_iono_tile_sat_los` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseIonoTileSatelliteLoS` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseIonoTileSatelliteLoS` were added. + pub fn use_iono_tile_satellite_lo_s(&self) -> Result { + get_bit_range!(self.use_iono_tile_sat_los, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseIonoTileSatelliteLoS][UseIonoTileSatelliteLoS] of the `use_iono_tile_sat_los` bitfield. + pub fn set_use_iono_tile_satellite_lo_s( + &mut self, + use_iono_tile_satellite_lo_s: UseIonoTileSatelliteLoS, + ) { + set_bit_range!( + &mut self.use_iono_tile_sat_los, + use_iono_tile_satellite_lo_s, + u8, + u8, + 2, + 0 + ); + } + + /// Gets the [UseIonoGridPointSatelliteLoS][self::UseIonoGridPointSatelliteLoS] stored in the `use_iono_grid_point_sat_los` bitfield. + /// + /// Returns `Ok` if the bitrange contains a known `UseIonoGridPointSatelliteLoS` variant. + /// Otherwise the value of the bitrange is returned as an `Err(u8)`. This may be because of a malformed message, + /// or because new variants of `UseIonoGridPointSatelliteLoS` were added. + pub fn use_iono_grid_point_satellite_lo_s( + &self, + ) -> Result { + get_bit_range!(self.use_iono_grid_point_sat_los, u8, u8, 2, 0).try_into() + } + + /// Set the bitrange corresponding to the [UseIonoGridPointSatelliteLoS][UseIonoGridPointSatelliteLoS] of the `use_iono_grid_point_sat_los` bitfield. + pub fn set_use_iono_grid_point_satellite_lo_s( + &mut self, + use_iono_grid_point_satellite_lo_s: UseIonoGridPointSatelliteLoS, + ) { + set_bit_range!( + &mut self.use_iono_grid_point_sat_los, + use_iono_grid_point_satellite_lo_s, + u8, + u8, + 2, + 0 + ); + } + } + + impl ConcreteMessage for MsgSsrFlagHighLevelDepA { + const MESSAGE_TYPE: u16 = 3001; + const MESSAGE_NAME: &'static str = "MSG_SSR_FLAG_HIGH_LEVEL_DEP_A"; + } + + impl SbpMessage for MsgSsrFlagHighLevelDepA { + fn message_name(&self) -> &'static str { + ::MESSAGE_NAME + } + fn message_type(&self) -> Option { + Some(::MESSAGE_TYPE) + } + fn sender_id(&self) -> Option { + self.sender_id + } + fn set_sender_id(&mut self, new_id: u16) { + self.sender_id = Some(new_id); + } + fn encoded_len(&self) -> usize { + WireFormat::len(self) + crate::HEADER_LEN + crate::CRC_LEN + } + fn is_valid(&self) -> bool { + true + } + fn into_valid_msg(self) -> Result { + Ok(self) + } + } + + impl FriendlyName for MsgSsrFlagHighLevelDepA { + fn friendly_name() -> &'static str { + "SSR FLAG HIGH LEVEL DEP A" + } + } + + impl TryFrom for MsgSsrFlagHighLevelDepA { + type Error = TryFromSbpError; + fn try_from(msg: Sbp) -> Result { + match msg { + Sbp::MsgSsrFlagHighLevelDepA(m) => Ok(m), + _ => Err(TryFromSbpError(msg)), + } + } + } + + impl WireFormat for MsgSsrFlagHighLevelDepA { + const MIN_LEN: usize = ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + <[u8; 5] as WireFormat>::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN + + ::MIN_LEN; + fn len(&self) -> usize { + WireFormat::len(&self.obs_time) + + WireFormat::len(&self.corr_time) + + WireFormat::len(&self.ssr_sol_id) + + WireFormat::len(&self.tile_set_id) + + WireFormat::len(&self.tile_id) + + WireFormat::len(&self.chain_id) + + WireFormat::len(&self.use_gps_sat) + + WireFormat::len(&self.use_gal_sat) + + WireFormat::len(&self.use_bds_sat) + + WireFormat::len(&self.use_qzss_sat) + + WireFormat::len(&self.reserved) + + WireFormat::len(&self.use_tropo_grid_points) + + WireFormat::len(&self.use_iono_grid_points) + + WireFormat::len(&self.use_iono_tile_sat_los) + + WireFormat::len(&self.use_iono_grid_point_sat_los) + } + fn write(&self, buf: &mut B) { + WireFormat::write(&self.obs_time, buf); + WireFormat::write(&self.corr_time, buf); + WireFormat::write(&self.ssr_sol_id, buf); + WireFormat::write(&self.tile_set_id, buf); + WireFormat::write(&self.tile_id, buf); + WireFormat::write(&self.chain_id, buf); + WireFormat::write(&self.use_gps_sat, buf); + WireFormat::write(&self.use_gal_sat, buf); + WireFormat::write(&self.use_bds_sat, buf); + WireFormat::write(&self.use_qzss_sat, buf); + WireFormat::write(&self.reserved, buf); + WireFormat::write(&self.use_tropo_grid_points, buf); + WireFormat::write(&self.use_iono_grid_points, buf); + WireFormat::write(&self.use_iono_tile_sat_los, buf); + WireFormat::write(&self.use_iono_grid_point_sat_los, buf); + } + fn parse_unchecked(buf: &mut B) -> Self { + MsgSsrFlagHighLevelDepA { sender_id: None, obs_time: WireFormat::parse_unchecked(buf), corr_time: WireFormat::parse_unchecked(buf), diff --git a/rust/sbp/src/messages/mod.rs b/rust/sbp/src/messages/mod.rs index e4c86f0d2..754cca7f6 100644 --- a/rust/sbp/src/messages/mod.rs +++ b/rust/sbp/src/messages/mod.rs @@ -81,6 +81,7 @@ use self::imu::msg_imu_comp::MsgImuComp; use self::imu::msg_imu_raw::MsgImuRaw; use self::integrity::msg_acknowledge::MsgAcknowledge; use self::integrity::msg_ssr_flag_high_level::MsgSsrFlagHighLevel; +use self::integrity::msg_ssr_flag_high_level_dep_a::MsgSsrFlagHighLevelDepA; use self::integrity::msg_ssr_flag_iono_grid_point_sat_los::MsgSsrFlagIonoGridPointSatLos; use self::integrity::msg_ssr_flag_iono_grid_points::MsgSsrFlagIonoGridPoints; use self::integrity::msg_ssr_flag_iono_tile_sat_los::MsgSsrFlagIonoTileSatLos; @@ -769,6 +770,8 @@ pub enum Sbp { MsgWheeltick(MsgWheeltick), /// Compensated IMU data MsgImuComp(MsgImuComp), + /// Deprecated + MsgSsrFlagHighLevelDepA(MsgSsrFlagHighLevelDepA), /// High level integrity flags MsgSsrFlagHighLevel(MsgSsrFlagHighLevel), /// List of satellites which are faulty, per constellation @@ -1477,6 +1480,10 @@ impl<'de> serde::Deserialize<'de> for Sbp { Some(MsgImuComp::MESSAGE_TYPE) => { serde_json::from_value::(value).map(Sbp::MsgImuComp) } + Some(MsgSsrFlagHighLevelDepA::MESSAGE_TYPE) => { + serde_json::from_value::(value) + .map(Sbp::MsgSsrFlagHighLevelDepA) + } Some(MsgSsrFlagHighLevel::MESSAGE_TYPE) => { serde_json::from_value::(value).map(Sbp::MsgSsrFlagHighLevel) } @@ -2194,6 +2201,9 @@ impl Sbp { MsgOdometry::MESSAGE_TYPE => MsgOdometry::parse(&mut payload).map(Sbp::MsgOdometry), MsgWheeltick::MESSAGE_TYPE => MsgWheeltick::parse(&mut payload).map(Sbp::MsgWheeltick), MsgImuComp::MESSAGE_TYPE => MsgImuComp::parse(&mut payload).map(Sbp::MsgImuComp), + MsgSsrFlagHighLevelDepA::MESSAGE_TYPE => { + MsgSsrFlagHighLevelDepA::parse(&mut payload).map(Sbp::MsgSsrFlagHighLevelDepA) + } MsgSsrFlagHighLevel::MESSAGE_TYPE => { MsgSsrFlagHighLevel::parse(&mut payload).map(Sbp::MsgSsrFlagHighLevel) } @@ -2551,6 +2561,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.message_name(), Sbp::MsgWheeltick(msg) => msg.message_name(), Sbp::MsgImuComp(msg) => msg.message_name(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.message_name(), Sbp::MsgSsrFlagHighLevel(msg) => msg.message_name(), Sbp::MsgSsrFlagSatellites(msg) => msg.message_name(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.message_name(), @@ -2797,6 +2808,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.message_type(), Sbp::MsgWheeltick(msg) => msg.message_type(), Sbp::MsgImuComp(msg) => msg.message_type(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.message_type(), Sbp::MsgSsrFlagHighLevel(msg) => msg.message_type(), Sbp::MsgSsrFlagSatellites(msg) => msg.message_type(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.message_type(), @@ -3043,6 +3055,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.sender_id(), Sbp::MsgWheeltick(msg) => msg.sender_id(), Sbp::MsgImuComp(msg) => msg.sender_id(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.sender_id(), Sbp::MsgSsrFlagHighLevel(msg) => msg.sender_id(), Sbp::MsgSsrFlagSatellites(msg) => msg.sender_id(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.sender_id(), @@ -3289,6 +3302,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.set_sender_id(new_id), Sbp::MsgWheeltick(msg) => msg.set_sender_id(new_id), Sbp::MsgImuComp(msg) => msg.set_sender_id(new_id), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrFlagHighLevel(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrFlagSatellites(msg) => msg.set_sender_id(new_id), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.set_sender_id(new_id), @@ -3535,6 +3549,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.encoded_len(), Sbp::MsgWheeltick(msg) => msg.encoded_len(), Sbp::MsgImuComp(msg) => msg.encoded_len(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.encoded_len(), Sbp::MsgSsrFlagHighLevel(msg) => msg.encoded_len(), Sbp::MsgSsrFlagSatellites(msg) => msg.encoded_len(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.encoded_len(), @@ -3784,6 +3799,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.gps_time(), Sbp::MsgWheeltick(msg) => msg.gps_time(), Sbp::MsgImuComp(msg) => msg.gps_time(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.gps_time(), Sbp::MsgSsrFlagHighLevel(msg) => msg.gps_time(), Sbp::MsgSsrFlagSatellites(msg) => msg.gps_time(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.gps_time(), @@ -4030,6 +4046,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.friendly_name(), Sbp::MsgWheeltick(msg) => msg.friendly_name(), Sbp::MsgImuComp(msg) => msg.friendly_name(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.friendly_name(), Sbp::MsgSsrFlagHighLevel(msg) => msg.friendly_name(), Sbp::MsgSsrFlagSatellites(msg) => msg.friendly_name(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.friendly_name(), @@ -4276,6 +4293,7 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => msg.is_valid(), Sbp::MsgWheeltick(msg) => msg.is_valid(), Sbp::MsgImuComp(msg) => msg.is_valid(), + Sbp::MsgSsrFlagHighLevelDepA(msg) => msg.is_valid(), Sbp::MsgSsrFlagHighLevel(msg) => msg.is_valid(), Sbp::MsgSsrFlagSatellites(msg) => msg.is_valid(), Sbp::MsgSsrFlagTropoGridPoints(msg) => msg.is_valid(), @@ -4583,6 +4601,9 @@ impl SbpMessage for Sbp { Sbp::MsgOdometry(msg) => Ok(Sbp::MsgOdometry(msg.into_valid_msg()?)), Sbp::MsgWheeltick(msg) => Ok(Sbp::MsgWheeltick(msg.into_valid_msg()?)), Sbp::MsgImuComp(msg) => Ok(Sbp::MsgImuComp(msg.into_valid_msg()?)), + Sbp::MsgSsrFlagHighLevelDepA(msg) => { + Ok(Sbp::MsgSsrFlagHighLevelDepA(msg.into_valid_msg()?)) + } Sbp::MsgSsrFlagHighLevel(msg) => Ok(Sbp::MsgSsrFlagHighLevel(msg.into_valid_msg()?)), Sbp::MsgSsrFlagSatellites(msg) => Ok(Sbp::MsgSsrFlagSatellites(msg.into_valid_msg()?)), Sbp::MsgSsrFlagTropoGridPoints(msg) => { @@ -4878,6 +4899,7 @@ impl WireFormat for Sbp { Sbp::MsgOdometry(msg) => WireFormat::write(msg, buf), Sbp::MsgWheeltick(msg) => WireFormat::write(msg, buf), Sbp::MsgImuComp(msg) => WireFormat::write(msg, buf), + Sbp::MsgSsrFlagHighLevelDepA(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrFlagHighLevel(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrFlagSatellites(msg) => WireFormat::write(msg, buf), Sbp::MsgSsrFlagTropoGridPoints(msg) => WireFormat::write(msg, buf), @@ -5124,6 +5146,7 @@ impl WireFormat for Sbp { Sbp::MsgOdometry(msg) => WireFormat::len(msg), Sbp::MsgWheeltick(msg) => WireFormat::len(msg), Sbp::MsgImuComp(msg) => WireFormat::len(msg), + Sbp::MsgSsrFlagHighLevelDepA(msg) => WireFormat::len(msg), Sbp::MsgSsrFlagHighLevel(msg) => WireFormat::len(msg), Sbp::MsgSsrFlagSatellites(msg) => WireFormat::len(msg), Sbp::MsgSsrFlagTropoGridPoints(msg) => WireFormat::len(msg), @@ -6314,6 +6337,12 @@ impl From for Sbp { } } +impl From for Sbp { + fn from(msg: MsgSsrFlagHighLevelDepA) -> Self { + Sbp::MsgSsrFlagHighLevelDepA(msg) + } +} + impl From for Sbp { fn from(msg: MsgSsrFlagHighLevel) -> Self { Sbp::MsgSsrFlagHighLevel(msg) diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs index cbccb955c..9d8a08602 100644 --- a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs @@ -22,8 +22,8 @@ use crate::*; fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { { let mut payload = Cursor::new(vec![ - 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, - 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + 85, 186, 11, 66, 0, 37, 180, 0, 0, 0, 3, 0, 109, 1, 0, 0, 6, 0, 104, 1, 0, 0, 6, 0, 10, + 20, 0, 30, 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 177, 238, ]); // Test the round trip payload parsing @@ -46,19 +46,19 @@ fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { "incorrect sender id, expected 0x0042, is {sender_id}" ); assert_eq!( - msg.chain_id, 40, - "incorrect value for chain_id, expected 40, is {}", - msg.chain_id + msg.atmo_corr_time.tow, 365, + "incorrect value for atmo_corr_time.tow, expected 365, is {}", + msg.atmo_corr_time.tow ); assert_eq!( - msg.corr_time.tow, 360, - "incorrect value for corr_time.tow, expected 360, is {}", - msg.corr_time.tow + msg.atmo_corr_time.wn, 6, + "incorrect value for atmo_corr_time.wn, expected 6, is {}", + msg.atmo_corr_time.wn ); assert_eq!( - msg.corr_time.wn, 6, - "incorrect value for corr_time.wn, expected 6, is {}", - msg.corr_time.wn + msg.chain_id, 40, + "incorrect value for chain_id, expected 40, is {}", + msg.chain_id ); assert_eq!( msg.obs_time.tow, 180, @@ -95,6 +95,16 @@ fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { "incorrect value for reserved[4], expected 0, is {}", msg.reserved[4] ); + assert_eq!( + msg.sat_corr_time.tow, 360, + "incorrect value for sat_corr_time.tow, expected 360, is {}", + msg.sat_corr_time.tow + ); + assert_eq!( + msg.sat_corr_time.wn, 6, + "incorrect value for sat_corr_time.wn, expected 6, is {}", + msg.sat_corr_time.wn + ); assert_eq!( msg.ssr_sol_id, 10, "incorrect value for ssr_sol_id, expected 10, is {}", @@ -169,7 +179,7 @@ fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { #[cfg(feature = "json")] fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level() { { - let json_input = r#"{"obs_time": {"tow": 180, "wn": 3}, "corr_time": {"tow": 360, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, "preamble": 85, "msg_type": 3001, "sender": 66, "length": 31, "payload": "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 873}"#.as_bytes(); + let json_input = r#"{"obs_time": {"tow": 180, "wn": 3}, "sat_corr_time": {"tow": 360, "wn": 6}, "atmo_corr_time": {"tow": 365, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, "preamble": 85, "msg_type": 3002, "sender": 66, "length": 37, "payload": "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 61105}"#.as_bytes(); let sbp_msg = { // JSON to SBP message from payload @@ -202,19 +212,19 @@ fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level() { "incorrect sender id, expected 0x0042, is {sender_id}" ); assert_eq!( - msg.chain_id, 40, - "incorrect value for chain_id, expected 40, is {}", - msg.chain_id + msg.atmo_corr_time.tow, 365, + "incorrect value for atmo_corr_time.tow, expected 365, is {}", + msg.atmo_corr_time.tow ); assert_eq!( - msg.corr_time.tow, 360, - "incorrect value for corr_time.tow, expected 360, is {}", - msg.corr_time.tow + msg.atmo_corr_time.wn, 6, + "incorrect value for atmo_corr_time.wn, expected 6, is {}", + msg.atmo_corr_time.wn ); assert_eq!( - msg.corr_time.wn, 6, - "incorrect value for corr_time.wn, expected 6, is {}", - msg.corr_time.wn + msg.chain_id, 40, + "incorrect value for chain_id, expected 40, is {}", + msg.chain_id ); assert_eq!( msg.obs_time.tow, 180, @@ -251,6 +261,16 @@ fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level() { "incorrect value for reserved[4], expected 0, is {}", msg.reserved[4] ); + assert_eq!( + msg.sat_corr_time.tow, 360, + "incorrect value for sat_corr_time.tow, expected 360, is {}", + msg.sat_corr_time.tow + ); + assert_eq!( + msg.sat_corr_time.wn, 6, + "incorrect value for sat_corr_time.wn, expected 6, is {}", + msg.sat_corr_time.wn + ); assert_eq!( msg.ssr_sol_id, 10, "incorrect value for ssr_sol_id, expected 10, is {}", @@ -325,8 +345,8 @@ fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level() { fn test_sbp2json_auto_check_sbp_integrity_msg_ssr_flag_high_level() { { let mut payload = Cursor::new(vec![ - 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, - 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + 85, 186, 11, 66, 0, 37, 180, 0, 0, 0, 3, 0, 109, 1, 0, 0, 6, 0, 104, 1, 0, 0, 6, 0, 10, + 20, 0, 30, 0, 40, 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 177, 238, ]); // Construct sbp message @@ -366,19 +386,19 @@ fn test_sbp2json_auto_check_sbp_integrity_msg_ssr_flag_high_level() { "incorrect sender id, expected 0x0042, is {sender_id}" ); assert_eq!( - msg.chain_id, 40, - "incorrect value for chain_id, expected 40, is {}", - msg.chain_id + msg.atmo_corr_time.tow, 365, + "incorrect value for atmo_corr_time.tow, expected 365, is {}", + msg.atmo_corr_time.tow ); assert_eq!( - msg.corr_time.tow, 360, - "incorrect value for corr_time.tow, expected 360, is {}", - msg.corr_time.tow + msg.atmo_corr_time.wn, 6, + "incorrect value for atmo_corr_time.wn, expected 6, is {}", + msg.atmo_corr_time.wn ); assert_eq!( - msg.corr_time.wn, 6, - "incorrect value for corr_time.wn, expected 6, is {}", - msg.corr_time.wn + msg.chain_id, 40, + "incorrect value for chain_id, expected 40, is {}", + msg.chain_id ); assert_eq!( msg.obs_time.tow, 180, @@ -415,6 +435,16 @@ fn test_sbp2json_auto_check_sbp_integrity_msg_ssr_flag_high_level() { "incorrect value for reserved[4], expected 0, is {}", msg.reserved[4] ); + assert_eq!( + msg.sat_corr_time.tow, 360, + "incorrect value for sat_corr_time.tow, expected 360, is {}", + msg.sat_corr_time.tow + ); + assert_eq!( + msg.sat_corr_time.wn, 6, + "incorrect value for sat_corr_time.wn, expected 6, is {}", + msg.sat_corr_time.wn + ); assert_eq!( msg.ssr_sol_id, 10, "incorrect value for ssr_sol_id, expected 10, is {}", diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs new file mode 100644 index 000000000..e395219ce --- /dev/null +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs @@ -0,0 +1,484 @@ +// +// Copyright (C) 2019-2021 Swift Navigation Inc. +// Contact: https://support.swiftnav.com +// +// This source is subject to the license found in the file 'LICENSE' which must +// be distributed together with this source. All other rights reserved. +// +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml by generate.py. Do not modify by hand! + +use crate::*; + +/// Tests [`sbp::iter_messages`], from payload into SBP messages +/// +/// Asserts: +/// - SBP fields equates to that of the field +/// - Payload is identical +#[test] +fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a() { + { + let mut payload = Cursor::new(vec![ + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, + 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + ]); + + // Test the round trip payload parsing + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrFlagHighLevelDepA(msg) => { + let msg_type = msg.message_type().unwrap(); + assert_eq!( + msg_type, 3001, + "Incorrect message type, expected 3001, is {}", + msg_type + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {sender_id}" + ); + assert_eq!( + msg.chain_id, 40, + "incorrect value for chain_id, expected 40, is {}", + msg.chain_id + ); + assert_eq!( + msg.corr_time.tow, 360, + "incorrect value for corr_time.tow, expected 360, is {}", + msg.corr_time.tow + ); + assert_eq!( + msg.corr_time.wn, 6, + "incorrect value for corr_time.wn, expected 6, is {}", + msg.corr_time.wn + ); + assert_eq!( + msg.obs_time.tow, 180, + "incorrect value for obs_time.tow, expected 180, is {}", + msg.obs_time.tow + ); + assert_eq!( + msg.obs_time.wn, 3, + "incorrect value for obs_time.wn, expected 3, is {}", + msg.obs_time.wn + ); + assert_eq!( + msg.reserved[0], 0, + "incorrect value for reserved[0], expected 0, is {}", + msg.reserved[0] + ); + assert_eq!( + msg.reserved[1], 0, + "incorrect value for reserved[1], expected 0, is {}", + msg.reserved[1] + ); + assert_eq!( + msg.reserved[2], 0, + "incorrect value for reserved[2], expected 0, is {}", + msg.reserved[2] + ); + assert_eq!( + msg.reserved[3], 0, + "incorrect value for reserved[3], expected 0, is {}", + msg.reserved[3] + ); + assert_eq!( + msg.reserved[4], 0, + "incorrect value for reserved[4], expected 0, is {}", + msg.reserved[4] + ); + assert_eq!( + msg.ssr_sol_id, 10, + "incorrect value for ssr_sol_id, expected 10, is {}", + msg.ssr_sol_id + ); + assert_eq!( + msg.tile_id, 30, + "incorrect value for tile_id, expected 30, is {}", + msg.tile_id + ); + assert_eq!( + msg.tile_set_id, 20, + "incorrect value for tile_set_id, expected 20, is {}", + msg.tile_set_id + ); + assert_eq!( + msg.use_bds_sat, 3, + "incorrect value for use_bds_sat, expected 3, is {}", + msg.use_bds_sat + ); + assert_eq!( + msg.use_gal_sat, 2, + "incorrect value for use_gal_sat, expected 2, is {}", + msg.use_gal_sat + ); + assert_eq!( + msg.use_gps_sat, 1, + "incorrect value for use_gps_sat, expected 1, is {}", + msg.use_gps_sat + ); + assert_eq!( + msg.use_iono_grid_point_sat_los, 8, + "incorrect value for use_iono_grid_point_sat_los, expected 8, is {}", + msg.use_iono_grid_point_sat_los + ); + assert_eq!( + msg.use_iono_grid_points, 6, + "incorrect value for use_iono_grid_points, expected 6, is {}", + msg.use_iono_grid_points + ); + assert_eq!( + msg.use_iono_tile_sat_los, 7, + "incorrect value for use_iono_tile_sat_los, expected 7, is {}", + msg.use_iono_tile_sat_los + ); + assert_eq!( + msg.use_qzss_sat, 4, + "incorrect value for use_qzss_sat, expected 4, is {}", + msg.use_qzss_sat + ); + assert_eq!( + msg.use_tropo_grid_points, 5, + "incorrect value for use_tropo_grid_points, expected 5, is {}", + msg.use_tropo_grid_points + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrFlagHighLevelDepA"), + }; + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} + +/// Tests [`sbp::json::iter_messages`] for JSON payload -> SBP message +/// and [`sbp::json::iter_messages_from_fields`] for JSON fields -> SBP message. +/// +/// Asserts: +/// - SBP message constructed via payload is identical to from fields +/// - SBP fields equates to that of the field +/// - Payload is identical +#[test] +#[cfg(feature = "json")] +fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a() { + { + let json_input = r#"{"obs_time": {"tow": 180, "wn": 3}, "corr_time": {"tow": 360, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, "preamble": 85, "msg_type": 3001, "sender": 66, "length": 31, "payload": "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 873}"#.as_bytes(); + + let sbp_msg = { + // JSON to SBP message from payload + let mut iter = json2sbp_iter_msg(json_input); + let from_payload = iter + .next() + .expect("no message found") + .expect("failed to parse message"); + + // JSON to SBP message from fields + let mut iter = iter_messages_from_fields(json_input); + let from_fields = iter + .next() + .expect("no message found") + .expect("failed to parse message"); + + assert_eq!(from_fields, from_payload); + from_fields + }; + match &sbp_msg { + sbp::messages::Sbp::MsgSsrFlagHighLevelDepA(msg) => { + let msg_type = msg.message_type().unwrap(); + assert_eq!( + msg_type, 3001, + "Incorrect message type, expected 3001, is {}", + msg_type + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {sender_id}" + ); + assert_eq!( + msg.chain_id, 40, + "incorrect value for chain_id, expected 40, is {}", + msg.chain_id + ); + assert_eq!( + msg.corr_time.tow, 360, + "incorrect value for corr_time.tow, expected 360, is {}", + msg.corr_time.tow + ); + assert_eq!( + msg.corr_time.wn, 6, + "incorrect value for corr_time.wn, expected 6, is {}", + msg.corr_time.wn + ); + assert_eq!( + msg.obs_time.tow, 180, + "incorrect value for obs_time.tow, expected 180, is {}", + msg.obs_time.tow + ); + assert_eq!( + msg.obs_time.wn, 3, + "incorrect value for obs_time.wn, expected 3, is {}", + msg.obs_time.wn + ); + assert_eq!( + msg.reserved[0], 0, + "incorrect value for reserved[0], expected 0, is {}", + msg.reserved[0] + ); + assert_eq!( + msg.reserved[1], 0, + "incorrect value for reserved[1], expected 0, is {}", + msg.reserved[1] + ); + assert_eq!( + msg.reserved[2], 0, + "incorrect value for reserved[2], expected 0, is {}", + msg.reserved[2] + ); + assert_eq!( + msg.reserved[3], 0, + "incorrect value for reserved[3], expected 0, is {}", + msg.reserved[3] + ); + assert_eq!( + msg.reserved[4], 0, + "incorrect value for reserved[4], expected 0, is {}", + msg.reserved[4] + ); + assert_eq!( + msg.ssr_sol_id, 10, + "incorrect value for ssr_sol_id, expected 10, is {}", + msg.ssr_sol_id + ); + assert_eq!( + msg.tile_id, 30, + "incorrect value for tile_id, expected 30, is {}", + msg.tile_id + ); + assert_eq!( + msg.tile_set_id, 20, + "incorrect value for tile_set_id, expected 20, is {}", + msg.tile_set_id + ); + assert_eq!( + msg.use_bds_sat, 3, + "incorrect value for use_bds_sat, expected 3, is {}", + msg.use_bds_sat + ); + assert_eq!( + msg.use_gal_sat, 2, + "incorrect value for use_gal_sat, expected 2, is {}", + msg.use_gal_sat + ); + assert_eq!( + msg.use_gps_sat, 1, + "incorrect value for use_gps_sat, expected 1, is {}", + msg.use_gps_sat + ); + assert_eq!( + msg.use_iono_grid_point_sat_los, 8, + "incorrect value for use_iono_grid_point_sat_los, expected 8, is {}", + msg.use_iono_grid_point_sat_los + ); + assert_eq!( + msg.use_iono_grid_points, 6, + "incorrect value for use_iono_grid_points, expected 6, is {}", + msg.use_iono_grid_points + ); + assert_eq!( + msg.use_iono_tile_sat_los, 7, + "incorrect value for use_iono_tile_sat_los, expected 7, is {}", + msg.use_iono_tile_sat_los + ); + assert_eq!( + msg.use_qzss_sat, 4, + "incorrect value for use_qzss_sat, expected 4, is {}", + msg.use_qzss_sat + ); + assert_eq!( + msg.use_tropo_grid_points, 5, + "incorrect value for use_tropo_grid_points, expected 5, is {}", + msg.use_tropo_grid_points + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrFlagHighLevelDepA"), + }; + } +} + +/// Tests [`sbp::json::JsonEncoder`] for roundtrip SBP message -> JSON +/// +/// Assumes: +/// - [`self::test_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a`] passes +/// +/// Asserts: +/// - SBP fields equates to that of the field +/// - Payload is identical +#[test] +#[cfg(feature = "json")] +fn test_sbp2json_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a() { + { + let mut payload = Cursor::new(vec![ + 85, 185, 11, 66, 0, 31, 180, 0, 0, 0, 3, 0, 104, 1, 0, 0, 6, 0, 10, 20, 0, 30, 0, 40, + 1, 2, 3, 4, 0, 0, 0, 0, 0, 5, 6, 7, 8, 105, 3, + ]); + + // Construct sbp message + let sbp_msg = { + let mut msgs = iter_messages(&mut payload); + msgs.next() + .expect("no message found") + .expect("failed to parse message") + }; + + let mut json_buffer = vec![]; + // Populate json buffer, CompactFormatter + sbp::json::JsonEncoder::new(&mut json_buffer, sbp::json::CompactFormatter {}) + .send(&sbp_msg) + .unwrap(); + + // Reconstruct Sbp message from json fields, roundtrip + let sbp_msg = sbp::messages::Sbp::MsgSsrFlagHighLevelDepA( + serde_json::from_str( + std::str::from_utf8(json_buffer.as_slice()) + .unwrap() + .to_string() + .as_str(), + ) + .unwrap(), + ); + match &sbp_msg { + sbp::messages::Sbp::MsgSsrFlagHighLevelDepA(msg) => { + let msg_type = msg.message_type().unwrap(); + assert_eq!( + msg_type, 3001, + "Incorrect message type, expected 3001, is {}", + msg_type + ); + let sender_id = msg.sender_id().unwrap(); + assert_eq!( + sender_id, 0x0042, + "incorrect sender id, expected 0x0042, is {sender_id}" + ); + assert_eq!( + msg.chain_id, 40, + "incorrect value for chain_id, expected 40, is {}", + msg.chain_id + ); + assert_eq!( + msg.corr_time.tow, 360, + "incorrect value for corr_time.tow, expected 360, is {}", + msg.corr_time.tow + ); + assert_eq!( + msg.corr_time.wn, 6, + "incorrect value for corr_time.wn, expected 6, is {}", + msg.corr_time.wn + ); + assert_eq!( + msg.obs_time.tow, 180, + "incorrect value for obs_time.tow, expected 180, is {}", + msg.obs_time.tow + ); + assert_eq!( + msg.obs_time.wn, 3, + "incorrect value for obs_time.wn, expected 3, is {}", + msg.obs_time.wn + ); + assert_eq!( + msg.reserved[0], 0, + "incorrect value for reserved[0], expected 0, is {}", + msg.reserved[0] + ); + assert_eq!( + msg.reserved[1], 0, + "incorrect value for reserved[1], expected 0, is {}", + msg.reserved[1] + ); + assert_eq!( + msg.reserved[2], 0, + "incorrect value for reserved[2], expected 0, is {}", + msg.reserved[2] + ); + assert_eq!( + msg.reserved[3], 0, + "incorrect value for reserved[3], expected 0, is {}", + msg.reserved[3] + ); + assert_eq!( + msg.reserved[4], 0, + "incorrect value for reserved[4], expected 0, is {}", + msg.reserved[4] + ); + assert_eq!( + msg.ssr_sol_id, 10, + "incorrect value for ssr_sol_id, expected 10, is {}", + msg.ssr_sol_id + ); + assert_eq!( + msg.tile_id, 30, + "incorrect value for tile_id, expected 30, is {}", + msg.tile_id + ); + assert_eq!( + msg.tile_set_id, 20, + "incorrect value for tile_set_id, expected 20, is {}", + msg.tile_set_id + ); + assert_eq!( + msg.use_bds_sat, 3, + "incorrect value for use_bds_sat, expected 3, is {}", + msg.use_bds_sat + ); + assert_eq!( + msg.use_gal_sat, 2, + "incorrect value for use_gal_sat, expected 2, is {}", + msg.use_gal_sat + ); + assert_eq!( + msg.use_gps_sat, 1, + "incorrect value for use_gps_sat, expected 1, is {}", + msg.use_gps_sat + ); + assert_eq!( + msg.use_iono_grid_point_sat_los, 8, + "incorrect value for use_iono_grid_point_sat_los, expected 8, is {}", + msg.use_iono_grid_point_sat_los + ); + assert_eq!( + msg.use_iono_grid_points, 6, + "incorrect value for use_iono_grid_points, expected 6, is {}", + msg.use_iono_grid_points + ); + assert_eq!( + msg.use_iono_tile_sat_los, 7, + "incorrect value for use_iono_tile_sat_los, expected 7, is {}", + msg.use_iono_tile_sat_los + ); + assert_eq!( + msg.use_qzss_sat, 4, + "incorrect value for use_qzss_sat, expected 4, is {}", + msg.use_qzss_sat + ); + assert_eq!( + msg.use_tropo_grid_points, 5, + "incorrect value for use_tropo_grid_points, expected 5, is {}", + msg.use_tropo_grid_points + ); + } + _ => panic!("Invalid message type! Expected a MsgSsrFlagHighLevelDepA"), + }; + + // Check payload is still identical + let frame = sbp::to_vec(&sbp_msg).unwrap(); + assert_eq!(frame, payload.into_inner()); + } +} diff --git a/rust/sbp/tests/integration/main.rs b/rust/sbp/tests/integration/main.rs index db3f62f8a..9d03f1779 100644 --- a/rust/sbp/tests/integration/main.rs +++ b/rust/sbp/tests/integration/main.rs @@ -48,6 +48,7 @@ mod auto_check_sbp_imu_msg_imu_comp; mod auto_check_sbp_imu_msg_imu_raw; mod auto_check_sbp_integrity_msg_acknowledge; mod auto_check_sbp_integrity_msg_ssr_flag_high_level; +mod auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a; mod auto_check_sbp_integrity_msg_ssr_flag_iono_grid_point_sat_los; mod auto_check_sbp_integrity_msg_ssr_flag_iono_grid_points; mod auto_check_sbp_integrity_msg_ssr_flag_iono_tile_sat_los; diff --git a/sbpjson/elm/SbpJson.elm b/sbpjson/elm/SbpJson.elm index 17b4fc634..4a631da1e 100644 --- a/sbpjson/elm/SbpJson.elm +++ b/sbpjson/elm/SbpJson.elm @@ -2854,9 +2854,10 @@ SSR_INTEGRITY_USAGE_NOT_MONITORED: Unable to verify the integrity flag of elemen group. -} type alias MsgSsrFlagHighLevel = - { chainID : Int - , corrTime : GpsTimeSEC + { atmoCorrTime : GpsTimeSEC + , chainID : Int , obsTime : GpsTimeSEC + , satCorrTime : GpsTimeSEC , ssrSolID : Int , tileID : Int , tileSetID : Int @@ -7278,9 +7279,10 @@ encodeCodePhaseBiasesSatSig x = msgSsrFlagHighLevel : Jdec.Decoder MsgSsrFlagHighLevel msgSsrFlagHighLevel = Jpipe.decode MsgSsrFlagHighLevel + |> Jpipe.required "atmo_corr_time" gpsTimeSEC |> Jpipe.required "chain_id" Jdec.int - |> Jpipe.required "corr_time" gpsTimeSEC |> Jpipe.required "obs_time" gpsTimeSEC + |> Jpipe.required "sat_corr_time" gpsTimeSEC |> Jpipe.required "ssr_sol_id" Jdec.int |> Jpipe.required "tile_id" Jdec.int |> Jpipe.required "tile_set_id" Jdec.int @@ -7296,9 +7298,10 @@ msgSsrFlagHighLevel = encodeMsgSsrFlagHighLevel : MsgSsrFlagHighLevel -> Jenc.Value encodeMsgSsrFlagHighLevel x = Jenc.object - [ ("chain_id", Jenc.int x.chainID) - , ("corr_time", encodeGpsTimeSEC x.corrTime) + [ ("atmo_corr_time", encodeGpsTimeSEC x.atmoCorrTime) + , ("chain_id", Jenc.int x.chainID) , ("obs_time", encodeGpsTimeSEC x.obsTime) + , ("sat_corr_time", encodeGpsTimeSEC x.satCorrTime) , ("ssr_sol_id", Jenc.int x.ssrSolID) , ("tile_id", Jenc.int x.tileID) , ("tile_set_id", Jenc.int x.tileSetID) diff --git a/sbpjson/typescript/SbpJson.ts b/sbpjson/typescript/SbpJson.ts index 21d23c70d..911e338d5 100644 --- a/sbpjson/typescript/SbpJson.ts +++ b/sbpjson/typescript/SbpJson.ts @@ -2445,9 +2445,10 @@ export interface CodePhaseBiasesSatSig { * group. */ export interface MsgSsrFlagHighLevel { + atmo_corr_time: GpsTimeSEC; chain_id: number; - corr_time: GpsTimeSEC; obs_time: GpsTimeSEC; + sat_corr_time: GpsTimeSEC; ssr_sol_id: number; tile_id: number; tile_set_id: number; @@ -6364,9 +6365,10 @@ const typeMap: any = { { json: "signal_id", js: "signal_id", typ: 0 }, ], "any"), "MsgSsrFlagHighLevel": o([ + { json: "atmo_corr_time", js: "atmo_corr_time", typ: r("GpsTimeSEC") }, { json: "chain_id", js: "chain_id", typ: 0 }, - { json: "corr_time", js: "corr_time", typ: r("GpsTimeSEC") }, { json: "obs_time", js: "obs_time", typ: r("GpsTimeSEC") }, + { json: "sat_corr_time", js: "sat_corr_time", typ: r("GpsTimeSEC") }, { json: "ssr_sol_id", js: "ssr_sol_id", typ: 0 }, { json: "tile_id", js: "tile_id", typ: 0 }, { json: "tile_set_id", js: "tile_set_id", typ: 0 }, diff --git a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml index 699affdfc..f56b1e4e8 100644 --- a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml +++ b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml @@ -1,46 +1,49 @@ description: Unit tests for swiftnav.sbp.integrity MsgSsrFlagHighLevel -generated_on: 2022-04-21 # manually generated +generated_on: 2025-07-09 # manually generated package: sbp.integrity tests: - -- msg: - fields: - obs_time: - tow: 180 - wn: 3 - corr_time: - tow: 360 - wn: 6 - ssr_sol_id: 10 - tile_set_id: 20 - tile_id: 30 - chain_id: 40 - use_gps_sat: 1 - use_gal_sat: 2 - use_bds_sat: 3 - use_qzss_sat: 4 - reserved: - - 0 - - 0 - - 0 - - 0 - - 0 - use_tropo_grid_points: 5 - use_iono_grid_points: 6 - use_iono_tile_sat_los: 7 - use_iono_grid_point_sat_los: 8 - module: sbp.integrity - name: MsgSsrFlagHighLevel - msg_type: '3001' - raw_json: '{"obs_time": {"tow": 180, "wn": 3}, "corr_time": {"tow": 360, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, - "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], - "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, - "preamble": 85, "msg_type": 3001, "sender": 66, "length": 31, "payload": "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 873}' - raw_packet: VbkLQgAftAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCGkD - sbp: - preamble: '0x55' - msg_type: '0x0BB9' - sender: '0x0042' - length: 31 - payload: tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA== - crc: '0x0369' + - msg: + fields: + obs_time: + tow: 180 + wn: 3 + sat_corr_time: + tow: 360 + wn: 6 + atmo_corr_time: + tow: 365 + wn: 6 + ssr_sol_id: 10 + tile_set_id: 20 + tile_id: 30 + chain_id: 40 + use_gps_sat: 1 + use_gal_sat: 2 + use_bds_sat: 3 + use_qzss_sat: 4 + reserved: + - 0 + - 0 + - 0 + - 0 + - 0 + use_tropo_grid_points: 5 + use_iono_grid_points: 6 + use_iono_tile_sat_los: 7 + use_iono_grid_point_sat_los: 8 + module: sbp.integrity + name: MsgSsrFlagHighLevel + msg_type: "3002" + raw_json: + '{"obs_time": {"tow": 180, "wn": 3}, "sat_corr_time": {"tow": 360, "wn": 6}, "atmo_corr_time": {"tow": 365, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, + "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], + "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, + "preamble": 85, "msg_type": 3002, "sender": 66, "length": 37, "payload": "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 61105}' + raw_packet: VboLQgAltAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCLHu + sbp: + preamble: "0x55" + msg_type: "0x0BBA" + sender: "0x0042" + length: 37 + payload: tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA== + crc: "0xEEB1" diff --git a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml new file mode 100644 index 000000000..91e510537 --- /dev/null +++ b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml @@ -0,0 +1,46 @@ +description: Unit tests for swiftnav.sbp.integrity MsgSsrFlagHighLevelDepA +generated_on: 2025-07-09 # manually generated +package: sbp.integrity +tests: + - msg: + fields: + obs_time: + tow: 180 + wn: 3 + corr_time: + tow: 360 + wn: 6 + ssr_sol_id: 10 + tile_set_id: 20 + tile_id: 30 + chain_id: 40 + use_gps_sat: 1 + use_gal_sat: 2 + use_bds_sat: 3 + use_qzss_sat: 4 + reserved: + - 0 + - 0 + - 0 + - 0 + - 0 + use_tropo_grid_points: 5 + use_iono_grid_points: 6 + use_iono_tile_sat_los: 7 + use_iono_grid_point_sat_los: 8 + module: sbp.integrity + name: MsgSsrFlagHighLevelDepA + msg_type: "3001" + raw_json: + '{"obs_time": {"tow": 180, "wn": 3}, "corr_time": {"tow": 360, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, + "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], + "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, + "preamble": 85, "msg_type": 3001, "sender": 66, "length": 31, "payload": "tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 873}' + raw_packet: VbkLQgAftAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCGkD + sbp: + preamble: "0x55" + msg_type: "0x0BB9" + sender: "0x0042" + length: 31 + payload: tAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA== + crc: "0x0369" From e0676ae3e55209e40bbc58fb642ea2197729ad3a Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Thu, 17 Jul 2025 16:57:20 +0200 Subject: [PATCH 05/10] Update --- spec/yaml/swiftnav/sbp/integrity.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/spec/yaml/swiftnav/sbp/integrity.yaml b/spec/yaml/swiftnav/sbp/integrity.yaml index 356f3d5d7..6777bcb8b 100644 --- a/spec/yaml/swiftnav/sbp/integrity.yaml +++ b/spec/yaml/swiftnav/sbp/integrity.yaml @@ -202,9 +202,9 @@ definitions: - obs_time: type: GPSTimeSec desc: GNSS reference time of the observation used to generate the flag. - - atmo_corr_time: + - iono_corr_time: type: GPSTimeSec - desc: GNSS reference time of the atmospheric correction associated to the flag. + desc: GNSS reference time of the ionospheric correction associated to the flag. - sat_corr_time: type: GPSTimeSec desc: GNSS reference time of the satellite correction associated to the flag. From 40c147106a1d690704ef8f1a2a56b0b374051eac Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Thu, 17 Jul 2025 17:06:27 +0200 Subject: [PATCH 06/10] Fix naming --- c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h | 4 ++-- c/src/integrity.c | 6 +++--- haskell/src/SwiftNav/SBP/Integrity.hs | 8 ++++---- python/sbp/integrity.py | 10 +++++----- rust/sbp/src/messages/integrity.rs | 12 ++++++------ ...to_check_sbp_integrity_msg_ssr_flag_high_level.rs | 12 ++++++------ ...ck_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs | 9 +++------ 7 files changed, 29 insertions(+), 32 deletions(-) diff --git a/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h b/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h index 254d1ba2e..b880a2e20 100644 --- a/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h +++ b/c/include/libsbp/integrity/MSG_SSR_FLAG_HIGH_LEVEL.h @@ -72,9 +72,9 @@ typedef struct { sbp_gps_time_sec_t obs_time; /** - * GNSS reference time of the atmospheric correction associated to the flag. + * GNSS reference time of the ionospheric correction associated to the flag. */ - sbp_gps_time_sec_t atmo_corr_time; + sbp_gps_time_sec_t iono_corr_time; /** * GNSS reference time of the satellite correction associated to the flag. diff --git a/c/src/integrity.c b/c/src/integrity.c index d873596fa..fa0bac3ce 100644 --- a/c/src/integrity.c +++ b/c/src/integrity.c @@ -379,7 +379,7 @@ bool sbp_msg_ssr_flag_high_level_encode_internal( if (!sbp_gps_time_sec_encode_internal(ctx, &msg->obs_time)) { return false; } - if (!sbp_gps_time_sec_encode_internal(ctx, &msg->atmo_corr_time)) { + if (!sbp_gps_time_sec_encode_internal(ctx, &msg->iono_corr_time)) { return false; } if (!sbp_gps_time_sec_encode_internal(ctx, &msg->sat_corr_time)) { @@ -450,7 +450,7 @@ bool sbp_msg_ssr_flag_high_level_decode_internal( if (!sbp_gps_time_sec_decode_internal(ctx, &msg->obs_time)) { return false; } - if (!sbp_gps_time_sec_decode_internal(ctx, &msg->atmo_corr_time)) { + if (!sbp_gps_time_sec_decode_internal(ctx, &msg->iono_corr_time)) { return false; } if (!sbp_gps_time_sec_decode_internal(ctx, &msg->sat_corr_time)) { @@ -539,7 +539,7 @@ int sbp_msg_ssr_flag_high_level_cmp(const sbp_msg_ssr_flag_high_level_t *a, return ret; } - ret = sbp_gps_time_sec_cmp(&a->atmo_corr_time, &b->atmo_corr_time); + ret = sbp_gps_time_sec_cmp(&a->iono_corr_time, &b->iono_corr_time); if (ret != 0) { return ret; } diff --git a/haskell/src/SwiftNav/SBP/Integrity.hs b/haskell/src/SwiftNav/SBP/Integrity.hs index ad0dd7dee..d278c06d4 100644 --- a/haskell/src/SwiftNav/SBP/Integrity.hs +++ b/haskell/src/SwiftNav/SBP/Integrity.hs @@ -188,8 +188,8 @@ msgSsrFlagHighLevel = 0x0BBA data MsgSsrFlagHighLevel = MsgSsrFlagHighLevel { _msgSsrFlagHighLevel_obs_time :: !GpsTimeSec -- ^ GNSS reference time of the observation used to generate the flag. - , _msgSsrFlagHighLevel_atmo_corr_time :: !GpsTimeSec - -- ^ GNSS reference time of the atmospheric correction associated to the + , _msgSsrFlagHighLevel_iono_corr_time :: !GpsTimeSec + -- ^ GNSS reference time of the ionospheric correction associated to the -- flag. , _msgSsrFlagHighLevel_sat_corr_time :: !GpsTimeSec -- ^ GNSS reference time of the satellite correction associated to the flag. @@ -224,7 +224,7 @@ data MsgSsrFlagHighLevel = MsgSsrFlagHighLevel instance Binary MsgSsrFlagHighLevel where get = do _msgSsrFlagHighLevel_obs_time <- get - _msgSsrFlagHighLevel_atmo_corr_time <- get + _msgSsrFlagHighLevel_iono_corr_time <- get _msgSsrFlagHighLevel_sat_corr_time <- get _msgSsrFlagHighLevel_ssr_sol_id <- getWord8 _msgSsrFlagHighLevel_tile_set_id <- getWord16le @@ -243,7 +243,7 @@ instance Binary MsgSsrFlagHighLevel where put MsgSsrFlagHighLevel {..} = do put _msgSsrFlagHighLevel_obs_time - put _msgSsrFlagHighLevel_atmo_corr_time + put _msgSsrFlagHighLevel_iono_corr_time put _msgSsrFlagHighLevel_sat_corr_time putWord8 _msgSsrFlagHighLevel_ssr_sol_id putWord16le _msgSsrFlagHighLevel_tile_set_id diff --git a/python/sbp/integrity.py b/python/sbp/integrity.py index cf1f22616..3f344f721 100644 --- a/python/sbp/integrity.py +++ b/python/sbp/integrity.py @@ -292,8 +292,8 @@ class MsgSsrFlagHighLevel(SBP): SBP parent object to inherit from. obs_time : GPSTimeSec GNSS reference time of the observation used to generate the flag. - atmo_corr_time : GPSTimeSec - GNSS reference time of the atmospheric correction associated to the flag. + iono_corr_time : GPSTimeSec + GNSS reference time of the ionospheric correction associated to the flag. sat_corr_time : GPSTimeSec GNSS reference time of the satellite correction associated to the flag. ssr_sol_id : int @@ -328,7 +328,7 @@ class MsgSsrFlagHighLevel(SBP): """ _parser = construct.Struct( 'obs_time' / GPSTimeSec._parser, - 'atmo_corr_time' / GPSTimeSec._parser, + 'iono_corr_time' / GPSTimeSec._parser, 'sat_corr_time' / GPSTimeSec._parser, 'ssr_sol_id' / construct.Int8ul, 'tile_set_id' / construct.Int16ul, @@ -345,7 +345,7 @@ class MsgSsrFlagHighLevel(SBP): 'use_iono_grid_point_sat_los' / construct.Int8ul,) __slots__ = [ 'obs_time', - 'atmo_corr_time', + 'iono_corr_time', 'sat_corr_time', 'ssr_sol_id', 'tile_set_id', @@ -373,7 +373,7 @@ def __init__(self, sbp=None, **kwargs): self.msg_type = SBP_MSG_SSR_FLAG_HIGH_LEVEL self.sender = kwargs.pop('sender', SENDER_ID) self.obs_time = kwargs.pop('obs_time') - self.atmo_corr_time = kwargs.pop('atmo_corr_time') + self.iono_corr_time = kwargs.pop('iono_corr_time') self.sat_corr_time = kwargs.pop('sat_corr_time') self.ssr_sol_id = kwargs.pop('ssr_sol_id') self.tile_set_id = kwargs.pop('tile_set_id') diff --git a/rust/sbp/src/messages/integrity.rs b/rust/sbp/src/messages/integrity.rs index 2ec6b8a98..2f0ad929f 100644 --- a/rust/sbp/src/messages/integrity.rs +++ b/rust/sbp/src/messages/integrity.rs @@ -889,10 +889,10 @@ pub mod msg_ssr_flag_high_level { /// GNSS reference time of the observation used to generate the flag. #[cfg_attr(feature = "serde", serde(rename = "obs_time"))] pub obs_time: GpsTimeSec, - /// GNSS reference time of the atmospheric correction associated to the + /// GNSS reference time of the ionospheric correction associated to the /// flag. - #[cfg_attr(feature = "serde", serde(rename = "atmo_corr_time"))] - pub atmo_corr_time: GpsTimeSec, + #[cfg_attr(feature = "serde", serde(rename = "iono_corr_time"))] + pub iono_corr_time: GpsTimeSec, /// GNSS reference time of the satellite correction associated to the flag. #[cfg_attr(feature = "serde", serde(rename = "sat_corr_time"))] pub sat_corr_time: GpsTimeSec, @@ -1151,7 +1151,7 @@ pub mod msg_ssr_flag_high_level { + ::MIN_LEN; fn len(&self) -> usize { WireFormat::len(&self.obs_time) - + WireFormat::len(&self.atmo_corr_time) + + WireFormat::len(&self.iono_corr_time) + WireFormat::len(&self.sat_corr_time) + WireFormat::len(&self.ssr_sol_id) + WireFormat::len(&self.tile_set_id) @@ -1169,7 +1169,7 @@ pub mod msg_ssr_flag_high_level { } fn write(&self, buf: &mut B) { WireFormat::write(&self.obs_time, buf); - WireFormat::write(&self.atmo_corr_time, buf); + WireFormat::write(&self.iono_corr_time, buf); WireFormat::write(&self.sat_corr_time, buf); WireFormat::write(&self.ssr_sol_id, buf); WireFormat::write(&self.tile_set_id, buf); @@ -1189,7 +1189,7 @@ pub mod msg_ssr_flag_high_level { MsgSsrFlagHighLevel { sender_id: None, obs_time: WireFormat::parse_unchecked(buf), - atmo_corr_time: WireFormat::parse_unchecked(buf), + iono_corr_time: WireFormat::parse_unchecked(buf), sat_corr_time: WireFormat::parse_unchecked(buf), ssr_sol_id: WireFormat::parse_unchecked(buf), tile_set_id: WireFormat::parse_unchecked(buf), diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs index 9d8a08602..b64d7127b 100644 --- a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs @@ -37,8 +37,8 @@ fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { sbp::messages::Sbp::MsgSsrFlagHighLevel(msg) => { let msg_type = msg.message_type().unwrap(); assert_eq!( - msg_type, 3001, - "Incorrect message type, expected 3001, is {msg_type}" + msg_type, 3002, + "Incorrect message type, expected 3002, is {msg_type}" ); let sender_id = msg.sender_id().unwrap(); assert_eq!( @@ -203,8 +203,8 @@ fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level() { sbp::messages::Sbp::MsgSsrFlagHighLevel(msg) => { let msg_type = msg.message_type().unwrap(); assert_eq!( - msg_type, 3001, - "Incorrect message type, expected 3001, is {msg_type}" + msg_type, 3002, + "Incorrect message type, expected 3002, is {msg_type}" ); let sender_id = msg.sender_id().unwrap(); assert_eq!( @@ -377,8 +377,8 @@ fn test_sbp2json_auto_check_sbp_integrity_msg_ssr_flag_high_level() { sbp::messages::Sbp::MsgSsrFlagHighLevel(msg) => { let msg_type = msg.message_type().unwrap(); assert_eq!( - msg_type, 3001, - "Incorrect message type, expected 3001, is {msg_type}" + msg_type, 3002, + "Incorrect message type, expected 3002, is {msg_type}" ); let sender_id = msg.sender_id().unwrap(); assert_eq!( diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs index e395219ce..4d47bb057 100644 --- a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a.rs @@ -38,8 +38,7 @@ fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a() { let msg_type = msg.message_type().unwrap(); assert_eq!( msg_type, 3001, - "Incorrect message type, expected 3001, is {}", - msg_type + "Incorrect message type, expected 3001, is {msg_type}" ); let sender_id = msg.sender_id().unwrap(); assert_eq!( @@ -195,8 +194,7 @@ fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a() { let msg_type = msg.message_type().unwrap(); assert_eq!( msg_type, 3001, - "Incorrect message type, expected 3001, is {}", - msg_type + "Incorrect message type, expected 3001, is {msg_type}" ); let sender_id = msg.sender_id().unwrap(); assert_eq!( @@ -360,8 +358,7 @@ fn test_sbp2json_auto_check_sbp_integrity_msg_ssr_flag_high_level_dep_a() { let msg_type = msg.message_type().unwrap(); assert_eq!( msg_type, 3001, - "Incorrect message type, expected 3001, is {}", - msg_type + "Incorrect message type, expected 3001, is {msg_type}" ); let sender_id = msg.sender_id().unwrap(); assert_eq!( From 0c8c53cccebba7f81d861b11d4ef352f18715aa9 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Thu, 17 Jul 2025 18:29:00 +0200 Subject: [PATCH 07/10] ? --- docs/sbp.pdf | Bin 567808 -> 567908 bytes .../sbp/acquisition/AcqSvProfile.java | 36 +- .../sbp/acquisition/AcqSvProfileDep.java | 36 +- .../sbp/acquisition/MsgAcqResult.java | 55 +- .../sbp/acquisition/MsgAcqResultDepA.java | 59 +- .../sbp/acquisition/MsgAcqResultDepB.java | 56 +- .../sbp/acquisition/MsgAcqResultDepC.java | 50 +- .../sbp/acquisition/MsgAcqSvProfile.java | 45 +- .../sbp/acquisition/MsgAcqSvProfileDep.java | 43 +- .../bootload/MsgBootloaderHandshakeDepA.java | 46 +- .../bootload/MsgBootloaderHandshakeReq.java | 42 +- .../bootload/MsgBootloaderHandshakeResp.java | 52 +- .../sbp/bootload/MsgBootloaderJumpToApp.java | 44 +- .../sbp/bootload/MsgNapDeviceDnaReq.java | 46 +- .../sbp/bootload/MsgNapDeviceDnaResp.java | 56 +- .../com/swiftnav/sbp/client/MessageTable.java | 270 +- .../swiftnav/sbp/ext_events/MsgExtEvent.java | 59 +- .../sbp/file_io/MsgFileioConfigReq.java | 49 +- .../sbp/file_io/MsgFileioConfigResp.java | 55 +- .../sbp/file_io/MsgFileioReadDirReq.java | 62 +- .../sbp/file_io/MsgFileioReadDirResp.java | 53 +- .../sbp/file_io/MsgFileioReadReq.java | 61 +- .../sbp/file_io/MsgFileioReadResp.java | 52 +- .../swiftnav/sbp/file_io/MsgFileioRemove.java | 49 +- .../sbp/file_io/MsgFileioWriteReq.java | 61 +- .../sbp/file_io/MsgFileioWriteResp.java | 49 +- .../com/swiftnav/sbp/flash/MsgFlashDone.java | 49 +- .../com/swiftnav/sbp/flash/MsgFlashErase.java | 51 +- .../swiftnav/sbp/flash/MsgFlashProgram.java | 61 +- .../swiftnav/sbp/flash/MsgFlashReadReq.java | 57 +- .../swiftnav/sbp/flash/MsgFlashReadResp.java | 57 +- .../sbp/flash/MsgM25FlashWriteStatus.java | 47 +- .../sbp/flash/MsgStmFlashLockSector.java | 46 +- .../sbp/flash/MsgStmFlashUnlockSector.java | 46 +- .../swiftnav/sbp/flash/MsgStmUniqueIdReq.java | 42 +- .../sbp/flash/MsgStmUniqueIdResp.java | 49 +- .../com/swiftnav/sbp/gnss/CarrierPhase.java | 16 +- java/src/com/swiftnav/sbp/gnss/GPSTime.java | 18 +- .../src/com/swiftnav/sbp/gnss/GPSTimeDep.java | 16 +- .../src/com/swiftnav/sbp/gnss/GPSTimeSec.java | 16 +- .../src/com/swiftnav/sbp/gnss/GnssSignal.java | 22 +- .../com/swiftnav/sbp/gnss/GnssSignalDep.java | 28 +- java/src/com/swiftnav/sbp/gnss/SvId.java | 22 +- java/src/com/swiftnav/sbp/imu/MsgImuAux.java | 51 +- java/src/com/swiftnav/sbp/imu/MsgImuComp.java | 67 +- java/src/com/swiftnav/sbp/imu/MsgImuRaw.java | 74 +- .../sbp/integrity/IntegritySSRHeader.java | 26 +- .../sbp/integrity/MsgAcknowledge.java | 56 +- .../sbp/integrity/MsgSsrFlagHighLevel.java | 120 +- .../integrity/MsgSsrFlagHighLevelDepA.java | 73 +- .../MsgSsrFlagIonoGridPointSatLos.java | 39 +- .../integrity/MsgSsrFlagIonoGridPoints.java | 39 +- .../integrity/MsgSsrFlagIonoTileSatLos.java | 37 +- .../sbp/integrity/MsgSsrFlagSatellites.java | 48 +- .../integrity/MsgSsrFlagTropoGridPoints.java | 39 +- .../swiftnav/sbp/linux/MsgLinuxCpuState.java | 58 +- .../sbp/linux/MsgLinuxCpuStateDepA.java | 52 +- .../swiftnav/sbp/linux/MsgLinuxMemState.java | 58 +- .../sbp/linux/MsgLinuxMemStateDepA.java | 52 +- .../sbp/linux/MsgLinuxProcessFdCount.java | 50 +- .../sbp/linux/MsgLinuxProcessFdSummary.java | 58 +- .../linux/MsgLinuxProcessSocketCounts.java | 70 +- .../linux/MsgLinuxProcessSocketQueues.java | 80 +- .../sbp/linux/MsgLinuxSocketUsage.java | 65 +- .../swiftnav/sbp/linux/MsgLinuxSysState.java | 59 +- .../sbp/linux/MsgLinuxSysStateDepA.java | 54 +- java/src/com/swiftnav/sbp/logging/MsgFwd.java | 60 +- java/src/com/swiftnav/sbp/logging/MsgLog.java | 49 +- .../com/swiftnav/sbp/logging/MsgPrintDep.java | 44 +- java/src/com/swiftnav/sbp/mag/MsgMagRaw.java | 57 +- .../EstimatedHorizontalErrorEllipse.java | 39 +- .../sbp/navigation/MsgAgeCorrections.java | 47 +- .../sbp/navigation/MsgBaselineECEF.java | 63 +- .../sbp/navigation/MsgBaselineECEFDepA.java | 56 +- .../navigation/MsgBaselineHeadingDepA.java | 50 +- .../sbp/navigation/MsgBaselineNED.java | 68 +- .../sbp/navigation/MsgBaselineNEDDepA.java | 61 +- .../com/swiftnav/sbp/navigation/MsgDops.java | 66 +- .../swiftnav/sbp/navigation/MsgDopsDepA.java | 54 +- .../swiftnav/sbp/navigation/MsgGPSTime.java | 74 +- .../sbp/navigation/MsgGPSTimeDepA.java | 53 +- .../sbp/navigation/MsgGPSTimeGnss.java | 73 +- .../swiftnav/sbp/navigation/MsgPosECEF.java | 72 +- .../sbp/navigation/MsgPosECEFCov.java | 83 +- .../sbp/navigation/MsgPosECEFCovGnss.java | 82 +- .../sbp/navigation/MsgPosECEFDepA.java | 56 +- .../sbp/navigation/MsgPosECEFGnss.java | 71 +- .../swiftnav/sbp/navigation/MsgPosLLH.java | 73 +- .../swiftnav/sbp/navigation/MsgPosLLHAcc.java | 117 +- .../swiftnav/sbp/navigation/MsgPosLLHCov.java | 83 +- .../sbp/navigation/MsgPosLLHCovGnss.java | 82 +- .../sbp/navigation/MsgPosLLHDepA.java | 61 +- .../sbp/navigation/MsgPosLLHGnss.java | 72 +- .../sbp/navigation/MsgPoseRelative.java | 118 +- .../sbp/navigation/MsgProtectionLevel.java | 99 +- .../navigation/MsgProtectionLevelDepA.java | 56 +- .../navigation/MsgReferenceFrameParam.java | 77 +- .../sbp/navigation/MsgUtcLeapSecond.java | 62 +- .../swiftnav/sbp/navigation/MsgUtcTime.java | 68 +- .../sbp/navigation/MsgUtcTimeGnss.java | 67 +- .../swiftnav/sbp/navigation/MsgVelBody.java | 83 +- .../swiftnav/sbp/navigation/MsgVelCog.java | 78 +- .../swiftnav/sbp/navigation/MsgVelECEF.java | 64 +- .../sbp/navigation/MsgVelECEFCov.java | 74 +- .../sbp/navigation/MsgVelECEFCovGnss.java | 73 +- .../sbp/navigation/MsgVelECEFDepA.java | 56 +- .../sbp/navigation/MsgVelECEFGnss.java | 63 +- .../swiftnav/sbp/navigation/MsgVelNED.java | 68 +- .../swiftnav/sbp/navigation/MsgVelNEDCov.java | 80 +- .../sbp/navigation/MsgVelNEDCovGnss.java | 79 +- .../sbp/navigation/MsgVelNEDDepA.java | 61 +- .../sbp/navigation/MsgVelNEDGnss.java | 68 +- .../src/com/swiftnav/sbp/ndb/MsgNdbEvent.java | 84 +- .../sbp/observation/AlmanacCommonContent.java | 50 +- .../observation/AlmanacCommonContentDep.java | 50 +- .../sbp/observation/CarrierPhaseDepA.java | 16 +- .../com/swiftnav/sbp/observation/Doppler.java | 16 +- .../observation/EphemerisCommonContent.java | 32 +- .../EphemerisCommonContentDepA.java | 32 +- .../EphemerisCommonContentDepB.java | 31 +- .../swiftnav/sbp/observation/GnssCapb.java | 55 +- .../sbp/observation/MsgAlmanacGPS.java | 68 +- .../sbp/observation/MsgAlmanacGPSDep.java | 62 +- .../sbp/observation/MsgAlmanacGlo.java | 66 +- .../sbp/observation/MsgAlmanacGloDep.java | 61 +- .../sbp/observation/MsgBasePosECEF.java | 55 +- .../sbp/observation/MsgBasePosLLH.java | 54 +- .../sbp/observation/MsgEphemerisBds.java | 121 +- .../sbp/observation/MsgEphemerisDepA.java | 106 +- .../sbp/observation/MsgEphemerisDepB.java | 108 +- .../sbp/observation/MsgEphemerisDepC.java | 112 +- .../sbp/observation/MsgEphemerisDepD.java | 112 +- .../sbp/observation/MsgEphemerisGPS.java | 105 +- .../sbp/observation/MsgEphemerisGPSDepE.java | 100 +- .../sbp/observation/MsgEphemerisGPSDepF.java | 100 +- .../sbp/observation/MsgEphemerisGal.java | 109 +- .../sbp/observation/MsgEphemerisGalDepA.java | 102 +- .../sbp/observation/MsgEphemerisGlo.java | 66 +- .../sbp/observation/MsgEphemerisGloDepA.java | 55 +- .../sbp/observation/MsgEphemerisGloDepB.java | 55 +- .../sbp/observation/MsgEphemerisGloDepC.java | 64 +- .../sbp/observation/MsgEphemerisGloDepD.java | 63 +- .../sbp/observation/MsgEphemerisQzss.java | 102 +- .../sbp/observation/MsgEphemerisSbas.java | 44 +- .../sbp/observation/MsgEphemerisSbasDepA.java | 55 +- .../sbp/observation/MsgEphemerisSbasDepB.java | 55 +- .../sbp/observation/MsgGloBiases.java | 55 +- .../swiftnav/sbp/observation/MsgGnssCapb.java | 48 +- .../sbp/observation/MsgGroupDelay.java | 60 +- .../sbp/observation/MsgGroupDelayDepA.java | 60 +- .../sbp/observation/MsgGroupDelayDepB.java | 60 +- .../com/swiftnav/sbp/observation/MsgIono.java | 64 +- .../com/swiftnav/sbp/observation/MsgObs.java | 57 +- .../swiftnav/sbp/observation/MsgObsDepA.java | 48 +- .../swiftnav/sbp/observation/MsgObsDepB.java | 48 +- .../swiftnav/sbp/observation/MsgObsDepC.java | 48 +- .../com/swiftnav/sbp/observation/MsgOsr.java | 45 +- .../swiftnav/sbp/observation/MsgSvAzEl.java | 45 +- .../observation/MsgSvConfigurationGPSDep.java | 46 +- .../sbp/observation/ObservationHeader.java | 22 +- .../sbp/observation/ObservationHeaderDep.java | 22 +- .../sbp/observation/PackedObsContent.java | 46 +- .../sbp/observation/PackedObsContentDepA.java | 28 +- .../sbp/observation/PackedObsContentDepB.java | 28 +- .../sbp/observation/PackedObsContentDepC.java | 28 +- .../sbp/observation/PackedOsrContent.java | 39 +- .../com/swiftnav/sbp/observation/SvAzEl.java | 18 +- .../sbp/orientation/MsgAngularRate.java | 66 +- .../sbp/orientation/MsgBaselineHeading.java | 56 +- .../sbp/orientation/MsgOrientEuler.java | 66 +- .../sbp/orientation/MsgOrientQuat.java | 70 +- java/src/com/swiftnav/sbp/piksi/Latency.java | 20 +- .../com/swiftnav/sbp/piksi/MsgAlmanac.java | 40 +- .../sbp/piksi/MsgCellModemStatus.java | 52 +- .../swiftnav/sbp/piksi/MsgCommandOutput.java | 49 +- .../com/swiftnav/sbp/piksi/MsgCommandReq.java | 48 +- .../swiftnav/sbp/piksi/MsgCommandResp.java | 48 +- .../com/swiftnav/sbp/piksi/MsgCwResults.java | 41 +- .../com/swiftnav/sbp/piksi/MsgCwStart.java | 41 +- .../swiftnav/sbp/piksi/MsgDeviceMonitor.java | 55 +- .../swiftnav/sbp/piksi/MsgFrontEndGain.java | 58 +- .../com/swiftnav/sbp/piksi/MsgIarState.java | 48 +- .../swiftnav/sbp/piksi/MsgInitBaseDep.java | 38 +- .../swiftnav/sbp/piksi/MsgMaskSatellite.java | 48 +- .../sbp/piksi/MsgMaskSatelliteDep.java | 46 +- .../sbp/piksi/MsgNetworkBandwidthUsage.java | 43 +- .../sbp/piksi/MsgNetworkStateReq.java | 40 +- .../sbp/piksi/MsgNetworkStateResp.java | 61 +- java/src/com/swiftnav/sbp/piksi/MsgReset.java | 44 +- .../com/swiftnav/sbp/piksi/MsgResetDep.java | 38 +- .../swiftnav/sbp/piksi/MsgResetFilters.java | 46 +- .../com/swiftnav/sbp/piksi/MsgSetTime.java | 39 +- .../src/com/swiftnav/sbp/piksi/MsgSpecan.java | 57 +- .../com/swiftnav/sbp/piksi/MsgSpecanDep.java | 57 +- .../swiftnav/sbp/piksi/MsgThreadState.java | 57 +- .../com/swiftnav/sbp/piksi/MsgUartState.java | 64 +- .../swiftnav/sbp/piksi/MsgUartStateDepa.java | 50 +- .../com/swiftnav/sbp/piksi/NetworkUsage.java | 23 +- java/src/com/swiftnav/sbp/piksi/Period.java | 20 +- .../com/swiftnav/sbp/piksi/UARTChannel.java | 24 +- .../sbp/profiling/MsgMeasurementPoint.java | 64 +- .../MsgProfilingResourceCounter.java | 50 +- .../sbp/profiling/MsgProfilingSystemInfo.java | 56 +- .../sbp/profiling/MsgProfilingThreadInfo.java | 58 +- .../sbp/profiling/ResourceBucket.java | 30 +- .../src/com/swiftnav/sbp/sbas/MsgSbasRaw.java | 53 +- .../settings/MsgSettingsReadByIndexDone.java | 39 +- .../settings/MsgSettingsReadByIndexReq.java | 50 +- .../settings/MsgSettingsReadByIndexResp.java | 70 +- .../sbp/settings/MsgSettingsReadReq.java | 59 +- .../sbp/settings/MsgSettingsReadResp.java | 58 +- .../sbp/settings/MsgSettingsRegister.java | 50 +- .../sbp/settings/MsgSettingsRegisterResp.java | 58 +- .../sbp/settings/MsgSettingsSave.java | 40 +- .../sbp/settings/MsgSettingsWrite.java | 59 +- .../sbp/settings/MsgSettingsWriteResp.java | 58 +- .../swiftnav/sbp/signing/ECDSASignature.java | 26 +- .../sbp/signing/MsgAesCmacSignature.java | 86 +- .../sbp/signing/MsgCertificateChain.java | 64 +- .../sbp/signing/MsgCertificateChainDep.java | 72 +- .../sbp/signing/MsgEcdsaCertificate.java | 60 +- .../sbp/signing/MsgEcdsaSignature.java | 86 +- .../sbp/signing/MsgEcdsaSignatureDepA.java | 89 +- .../sbp/signing/MsgEcdsaSignatureDepB.java | 98 +- .../sbp/signing/MsgEd25519CertificateDep.java | 57 +- .../sbp/signing/MsgEd25519SignatureDepA.java | 49 +- .../sbp/signing/MsgEd25519SignatureDepB.java | 73 +- .../src/com/swiftnav/sbp/signing/UtcTime.java | 26 +- .../sbp/solution_meta/GNSSInputType.java | 14 +- .../sbp/solution_meta/IMUInputType.java | 14 +- .../sbp/solution_meta/MsgSolnMeta.java | 104 +- .../sbp/solution_meta/MsgSolnMetaDepA.java | 94 +- .../sbp/solution_meta/OdoInputType.java | 14 +- .../sbp/solution_meta/SolutionInputType.java | 16 +- .../com/swiftnav/sbp/ssr/BoundsHeader.java | 22 +- .../swiftnav/sbp/ssr/CodeBiasesContent.java | 16 +- .../sbp/ssr/CodePhaseBiasesSatSig.java | 36 +- .../sbp/ssr/GridDefinitionHeaderDepA.java | 27 +- .../sbp/ssr/GriddedCorrectionHeader.java | 38 +- .../sbp/ssr/GriddedCorrectionHeaderDepA.java | 34 +- .../swiftnav/sbp/ssr/MsgSsrCodeBiases.java | 65 +- .../sbp/ssr/MsgSsrCodePhaseBiasesBounds.java | 41 +- .../sbp/ssr/MsgSsrGridDefinitionDepA.java | 57 +- .../sbp/ssr/MsgSsrGriddedCorrection.java | 51 +- .../ssr/MsgSsrGriddedCorrectionBounds.java | 73 +- .../sbp/ssr/MsgSsrGriddedCorrectionDepA.java | 50 +- .../ssr/MsgSsrGriddedCorrectionNoStdDepA.java | 50 +- .../swiftnav/sbp/ssr/MsgSsrOrbitClock.java | 84 +- .../sbp/ssr/MsgSsrOrbitClockBounds.java | 57 +- .../MsgSsrOrbitClockBoundsDegradation.java | 50 +- .../sbp/ssr/MsgSsrOrbitClockDepA.java | 81 +- .../swiftnav/sbp/ssr/MsgSsrPhaseBiases.java | 77 +- .../swiftnav/sbp/ssr/MsgSsrSatelliteApc.java | 51 +- .../sbp/ssr/MsgSsrSatelliteApcDep.java | 43 +- .../sbp/ssr/MsgSsrStecCorrection.java | 42 +- .../sbp/ssr/MsgSsrStecCorrectionDep.java | 45 +- .../sbp/ssr/MsgSsrStecCorrectionDepA.java | 46 +- .../sbp/ssr/MsgSsrTileDefinition.java | 177 +- .../sbp/ssr/MsgSsrTileDefinitionDepA.java | 163 +- .../sbp/ssr/MsgSsrTileDefinitionDepB.java | 165 +- .../com/swiftnav/sbp/ssr/OrbitClockBound.java | 36 +- .../sbp/ssr/OrbitClockBoundDegradation.java | 28 +- .../swiftnav/sbp/ssr/PhaseBiasesContent.java | 22 +- java/src/com/swiftnav/sbp/ssr/STECHeader.java | 31 +- .../com/swiftnav/sbp/ssr/STECHeaderDepA.java | 27 +- .../com/swiftnav/sbp/ssr/STECResidual.java | 26 +- .../swiftnav/sbp/ssr/STECResidualNoStd.java | 16 +- .../com/swiftnav/sbp/ssr/STECSatElement.java | 31 +- .../sbp/ssr/STECSatElementIntegrity.java | 22 +- .../com/swiftnav/sbp/ssr/SatelliteAPC.java | 36 +- .../sbp/ssr/TroposphericDelayCorrection.java | 26 +- .../ssr/TroposphericDelayCorrectionNoStd.java | 19 +- .../swiftnav/sbp/system/MsgCsacTelemetry.java | 53 +- .../sbp/system/MsgCsacTelemetryLabels.java | 53 +- .../swiftnav/sbp/system/MsgDgnssStatus.java | 53 +- .../sbp/system/MsgGnssTimeOffset.java | 54 +- .../com/swiftnav/sbp/system/MsgGroupMeta.java | 59 +- .../com/swiftnav/sbp/system/MsgHeartbeat.java | 56 +- .../com/swiftnav/sbp/system/MsgInsStatus.java | 46 +- .../swiftnav/sbp/system/MsgInsUpdates.java | 60 +- .../com/swiftnav/sbp/system/MsgPpsTime.java | 65 +- .../sbp/system/MsgSensorAidEvent.java | 63 +- .../com/swiftnav/sbp/system/MsgStartup.java | 52 +- .../swiftnav/sbp/system/MsgStatusJournal.java | 61 +- .../swiftnav/sbp/system/MsgStatusReport.java | 61 +- .../sbp/system/StatusJournalItem.java | 16 +- .../swiftnav/sbp/system/SubSystemReport.java | 18 +- .../com/swiftnav/sbp/telemetry/MsgTelSv.java | 61 +- .../swiftnav/sbp/telemetry/TelemetrySV.java | 30 +- .../sbp/tracking/MeasurementState.java | 21 +- .../sbp/tracking/MsgMeasurementState.java | 46 +- .../swiftnav/sbp/tracking/MsgTrackingIq.java | 48 +- .../sbp/tracking/MsgTrackingIqDepA.java | 47 +- .../sbp/tracking/MsgTrackingIqDepB.java | 47 +- .../sbp/tracking/MsgTrackingState.java | 46 +- .../sbp/tracking/MsgTrackingStateDepA.java | 43 +- .../sbp/tracking/MsgTrackingStateDepB.java | 43 +- .../tracking/MsgTrackingStateDetailedDep.java | 119 +- .../MsgTrackingStateDetailedDepA.java | 121 +- .../tracking/TrackingChannelCorrelation.java | 16 +- .../TrackingChannelCorrelationDep.java | 16 +- .../sbp/tracking/TrackingChannelState.java | 20 +- .../tracking/TrackingChannelStateDepA.java | 18 +- .../tracking/TrackingChannelStateDepB.java | 18 +- .../com/swiftnav/sbp/user/MsgUserData.java | 47 +- .../com/swiftnav/sbp/vehicle/MsgOdometry.java | 70 +- .../swiftnav/sbp/vehicle/MsgWheeltick.java | 87 +- ..._sbp_acquisition_MsgAcqResultDepATest.java | 162 +- ..._sbp_acquisition_MsgAcqResultDepBTest.java | 123 +- ..._sbp_acquisition_MsgAcqResultDepCTest.java | 123 +- ...heck_sbp_acquisition_MsgAcqResultTest.java | 36 +- ...bp_acquisition_MsgAcqSvProfileDepTest.java | 209 +- ...k_sbp_acquisition_MsgAcqSvProfileTest.java | 197 +- ...ootload_MsgBootloaderHandshakeReqTest.java | 26 +- ...otload_MsgBootloaderHandshakeRespTest.java | 74 +- ...p_bootload_MsgBootloaderJumptoAppTest.java | 30 +- ...k_sbp_bootload_MsgNapDeviceDnaReqTest.java | 23 +- ..._sbp_bootload_MsgNapDeviceDnaRespTest.java | 63 +- ..._check_sbp_ext_events_MsgExtEventTest.java | 57 +- ...ck_sbp_file_io_MsgFileioConfigReqTest.java | 31 +- ...k_sbp_file_io_MsgFileioConfigRespTest.java | 45 +- ...k_sbp_file_io_MsgFileioReadDirReqTest.java | Bin 2817 -> 2567 bytes ..._sbp_file_io_MsgFileioReadDirRespTest.java | Bin 3460 -> 2409 bytes ...heck_sbp_file_io_MsgFileioReadReqTest.java | Bin 3657 -> 2920 bytes ...eck_sbp_file_io_MsgFileioReadRespTest.java | 1289 ++-------- ...check_sbp_file_io_MsgFileioRemoveTest.java | Bin 1723 -> 1674 bytes ...ck_sbp_file_io_MsgFileioWriteRespTest.java | 31 +- ...auto_check_sbp_flash_MsgFlashDoneTest.java | 33 +- ...uto_check_sbp_flash_MsgFlashEraseTest.java | 36 +- ...o_check_sbp_flash_MsgFlashProgramTest.java | 1292 ++-------- ...o_check_sbp_flash_MsgFlashReadReqTest.java | 49 +- ..._check_sbp_flash_MsgFlashReadRespTest.java | 49 +- ..._sbp_flash_MsgM25FlashWriteStatusTest.java | 30 +- ...k_sbp_flash_MsgStmFlashLockSectorTest.java | 31 +- ...sbp_flash_MsgStmFlashUnlockSectorTest.java | 31 +- ...check_sbp_flash_MsgStmUniqueIdReqTest.java | 25 +- ...heck_sbp_flash_MsgStmUniqueIdRespTest.java | 88 +- .../auto_check_sbp_gnss_gnss_structsTest.java | 16 +- .../auto_check_sbp_imu_MsgImuAuxTest.java | 40 +- .../auto_check_sbp_imu_MsgImuCompTest.java | 64 +- .../auto_check_sbp_imu_MsgImuRawTest.java | 58 +- ...heck_sbp_integrity_MsgAcknowledgeTest.java | 63 +- ...integrity_MsgSsrFlagHighLevelDepATest.java | 143 +- ...sbp_integrity_MsgSsrFlagHighLevelTest.java | 154 +- ...ity_MsgSsrFlagIonoGridPointSatLosTest.java | 106 +- ...ntegrity_MsgSsrFlagIonoGridPointsTest.java | 98 +- ...ntegrity_MsgSsrFlagIonoTileSatLosTest.java | 100 +- ...bp_integrity_MsgSsrFlagSatellitesTest.java | 69 +- ...tegrity_MsgSsrFlagTropoGridPointsTest.java | 98 +- ...k_sbp_integrity_integrity_structsTest.java | 17 +- ...ck_sbp_linux_MsgLinuxCpuStateDepATest.java | Bin 4872 -> 3330 bytes ..._check_sbp_linux_MsgLinuxCpuStateTest.java | Bin 5758 -> 4068 bytes ...ck_sbp_linux_MsgLinuxMemStateDepATest.java | Bin 4874 -> 3332 bytes ..._check_sbp_linux_MsgLinuxMemStateTest.java | Bin 5758 -> 4068 bytes ..._sbp_linux_MsgLinuxProcessFdCountTest.java | 91 +- ...bp_linux_MsgLinuxProcessFdSummaryTest.java | Bin 2475 -> 2255 bytes ...linux_MsgLinuxProcessSocketCountsTest.java | 106 +- ...linux_MsgLinuxProcessSocketQueuesTest.java | Bin 7996 -> 5037 bytes ...eck_sbp_linux_MsgLinuxSocketUsageTest.java | 234 +- ...ck_sbp_linux_MsgLinuxSysStateDepATest.java | 58 +- ..._check_sbp_linux_MsgLinuxSysStateTest.java | 60 +- .../auto_check_sbp_logging_MsgFwdTest.java | 101 +- .../auto_check_sbp_logging_MsgLogTest.java | 77 +- ...uto_check_sbp_logging_MsgPrintDepTest.java | 189 +- .../auto_check_sbp_mag_MsgMagRawTest.java | 56 +- ..._sbp_navigation_MsgAgeCorrectionsTest.java | 33 +- ...bp_navigation_MsgBaselineECEFDepATest.java | 589 +---- ...ck_sbp_navigation_MsgBaselineECEFTest.java | 215 +- ...navigation_MsgBaselineHeadingDepATest.java | 54 +- ...sbp_navigation_MsgBaselineNEDDepATest.java | 553 +--- ...eck_sbp_navigation_MsgBaselineNEDTest.java | 313 +-- ..._check_sbp_navigation_MsgDopsDepATest.java | 306 +-- ...auto_check_sbp_navigation_MsgDopsTest.java | 64 +- ...eck_sbp_navigation_MsgGPSTimeDepATest.java | 381 +-- ...eck_sbp_navigation_MsgGPSTimeGNSSTest.java | 183 +- ...o_check_sbp_navigation_MsgGPSTimeTest.java | 197 +- ..._sbp_navigation_MsgPosECEFCovGNSSTest.java | 90 +- ...heck_sbp_navigation_MsgPosECEFCovTest.java | 91 +- ...eck_sbp_navigation_MsgPosECEFDepATest.java | 520 +--- ...eck_sbp_navigation_MsgPosECEFGNSSTest.java | 45 +- ...o_check_sbp_navigation_MsgPosECEFTest.java | 241 +- ...check_sbp_navigation_MsgPosLLHCovTest.java | 91 +- ...heck_sbp_navigation_MsgPosLLHDepATest.java | 617 +---- ...to_check_sbp_navigation_MsgPosLLHTest.java | 245 +- ...check_sbp_navigation_MsgPosLlhAccTest.java | 109 +- ...k_sbp_navigation_MsgPosLlhCovGnssTest.java | 90 +- ...heck_sbp_navigation_MsgPosLlhGnssTest.java | 80 +- ...ck_sbp_navigation_MsgPoseRelativeTest.java | 161 +- ...navigation_MsgProtectionLevelDepATest.java | 77 +- ...sbp_navigation_MsgProtectionLevelTest.java | 174 +- ...navigation_MsgReferenceFrameParamTest.java | Bin 12333 -> 9054 bytes ...k_sbp_navigation_MsgUTCLeapSecondTest.java | 62 +- ...eck_sbp_navigation_MsgUTCTimeGNSSTest.java | 59 +- ...o_check_sbp_navigation_MsgUTCTimeTest.java | 61 +- ...o_check_sbp_navigation_MsgVelBodyTest.java | 88 +- ...to_check_sbp_navigation_MsgVelCogTest.java | 176 +- ...heck_sbp_navigation_MsgVelECEFCovTest.java | 88 +- ...eck_sbp_navigation_MsgVelECEFDepATest.java | 449 +--- ...o_check_sbp_navigation_MsgVelECEFTest.java | 265 +- ..._sbp_navigation_MsgVelEcefCovGnssTest.java | 87 +- ...eck_sbp_navigation_MsgVelEcefGnssTest.java | 69 +- ...check_sbp_navigation_MsgVelNEDCOVTest.java | 88 +- ...heck_sbp_navigation_MsgVelNEDDepATest.java | 635 ++--- ...to_check_sbp_navigation_MsgVelNEDTest.java | 281 +- ...k_sbp_navigation_MsgVelNedCovGnssTest.java | 87 +- ...heck_sbp_navigation_MsgVelNedGnssTest.java | 77 +- ...sbp_navigation_navigation_structsTest.java | 17 +- .../auto_check_sbp_ndb_MsgNdbEventTest.java | 70 +- ..._sbp_observation_MsgAlmanacGLODepTest.java | 138 +- ...eck_sbp_observation_MsgAlmanacGLOTest.java | 132 +- ..._sbp_observation_MsgAlmanacGPSDepTest.java | 154 +- ...eck_sbp_observation_MsgAlmanacGPSTest.java | 148 +- ...ck_sbp_observation_MsgBasePosEcefTest.java | 49 +- ...eck_sbp_observation_MsgBasePosLLHTest.java | 29 +- ...k_sbp_observation_MsgEphemerisBdsTest.java | 215 +- ..._sbp_observation_MsgEphemerisDepATest.java | 218 +- ..._sbp_observation_MsgEphemerisDepCTest.java | 244 +- ..._sbp_observation_MsgEphemerisDepDTest.java | 244 +- ...p_observation_MsgEphemerisGLODepATest.java | 170 +- ...p_observation_MsgEphemerisGLODepBTest.java | 164 +- ...p_observation_MsgEphemerisGLODepCTest.java | 176 +- ...p_observation_MsgEphemerisGLODepDTest.java | 180 +- ...k_sbp_observation_MsgEphemerisGLOTest.java | 74 +- ...p_observation_MsgEphemerisGPSDepETest.java | 257 +- ...p_observation_MsgEphemerisGPSDepFTest.java | 251 +- ...k_sbp_observation_MsgEphemerisGPSTest.java | 207 +- ...p_observation_MsgEphemerisGalDepATest.java | 220 +- ...k_sbp_observation_MsgEphemerisGalTest.java | 224 +- ..._observation_MsgEphemerisSbasDepATest.java | 173 +- ..._observation_MsgEphemerisSbasDepBTest.java | 167 +- ..._sbp_observation_MsgEphemerisSbasTest.java | 128 +- ...heck_sbp_observation_MsgGloBiasesTest.java | 45 +- ...check_sbp_observation_MsgGnssCapbTest.java | 206 +- ...sbp_observation_MsgGroupDelayDepATest.java | 53 +- ...sbp_observation_MsgGroupDelayDepBTest.java | 61 +- ...eck_sbp_observation_MsgGroupDelayTest.java | 57 +- ...uto_check_sbp_observation_MsgIonoTest.java | 105 +- ..._check_sbp_observation_MsgObsDepBTest.java | 1143 ++------- ..._check_sbp_observation_MsgObsDepCTest.java | 1081 ++------ ...auto_check_sbp_observation_MsgObsTest.java | 891 ++----- ...auto_check_sbp_observation_MsgOsrTest.java | 763 +----- ...o_check_sbp_observation_MsgSvAzElTest.java | 575 ++--- ...ervation_MsgSvConfigurationGpsDepTest.java | 50 +- ..._sbp_observation_msgEphemerisDepBTest.java | 1242 +-------- ..._sbp_observation_msgEphemerisQzssTest.java | 207 +- ..._check_sbp_observation_msgObsDepATest.java | 1125 ++------ ...p_observation_observation_structsTest.java | 17 +- ...ck_sbp_orientation_MsgAngularRateTest.java | 44 +- ...bp_orientation_MsgBaselineHeadingTest.java | 50 +- ...ck_sbp_orientation_MsgOrientEulerTest.java | 70 +- ...eck_sbp_orientation_MsgOrientQuatTest.java | 81 +- .../auto_check_sbp_piksi_MsgAlmanacTest.java | 25 +- ...heck_sbp_piksi_MsgCellModemStatusTest.java | 1287 ++-------- ..._check_sbp_piksi_MsgCommandOutputTest.java | 38 +- ...uto_check_sbp_piksi_MsgCommandReqTest.java | Bin 2935 -> 2206 bytes ...to_check_sbp_piksi_MsgCommandRespTest.java | 44 +- ...auto_check_sbp_piksi_MsgCwResultsTest.java | 25 +- .../auto_check_sbp_piksi_MsgCwStartTest.java | 25 +- ..._check_sbp_piksi_MsgDeviceMonitorTest.java | 222 +- ...o_check_sbp_piksi_MsgFrontEndGainTest.java | 108 +- .../auto_check_sbp_piksi_MsgIarStateTest.java | 126 +- ...to_check_sbp_piksi_MsgInitBaseDepTest.java | 25 +- ...eck_sbp_piksi_MsgMaskSatelliteDepTest.java | 42 +- ..._check_sbp_piksi_MsgMaskSatelliteTest.java | 39 +- ...bp_piksi_MsgNetworkBandwidthUsageTest.java | Bin 16620 -> 11467 bytes ...heck_sbp_piksi_MsgNetworkStateReqTest.java | 25 +- ...eck_sbp_piksi_MsgNetworkStateRespTest.java | Bin 13311 -> 11262 bytes .../auto_check_sbp_piksi_MsgResetDepTest.java | 25 +- ...o_check_sbp_piksi_MsgResetFiltersTest.java | 33 +- .../auto_check_sbp_piksi_MsgResetTest.java | 33 +- .../auto_check_sbp_piksi_MsgSetTimeTest.java | 25 +- ...auto_check_sbp_piksi_MsgSpecanDepTest.java | 1219 ++------- .../auto_check_sbp_piksi_MsgSpecanTest.java | 1207 ++------- ...to_check_sbp_piksi_MsgThreadStateTest.java | Bin 23918 -> 17312 bytes ..._check_sbp_piksi_MsgUartStateDepATest.java | 717 +----- ...auto_check_sbp_piksi_MsgUartStateTest.java | 351 +-- ...uto_check_sbp_piksi_piksi_structsTest.java | 16 +- ...sbp_profiling_MsgMeasurementPointTest.java | Bin 5378 -> 4883 bytes ...iling_MsgProfilingResourceCounterTest.java | Bin 30109 -> 22802 bytes ..._profiling_MsgProfilingSystemInfoTest.java | 48 +- ..._profiling_MsgProfilingThreadInfoTest.java | Bin 4831 -> 3762 bytes .../auto_check_sbp_sbas_MsgSbasRawTest.java | 178 +- ...ttings_MsgSettingsReadByIndexDoneTest.java | 26 +- ...ettings_MsgSettingsReadByIndexReqTest.java | 34 +- ...ttings_MsgSettingsReadByIndexRespTest.java | Bin 11799 -> 7837 bytes ...k_sbp_settings_MsgSettingsReadReqTest.java | Bin 2392 -> 1824 bytes ..._sbp_settings_MsgSettingsReadRespTest.java | Bin 3720 -> 2255 bytes ..._settings_MsgSettingsRegisterRespTest.java | Bin 4192 -> 2638 bytes ..._sbp_settings_MsgSettingsRegisterTest.java | Bin 3720 -> 2255 bytes ...heck_sbp_settings_MsgSettingsSaveTest.java | 25 +- ...sbp_settings_MsgSettingsWriteRespTest.java | Bin 4176 -> 2623 bytes ...eck_sbp_settings_MsgSettingsWriteTest.java | Bin 2836 -> 1960 bytes ...k_sbp_signing_MsgAesCmacSignatureTest.java | 133 +- ...bp_signing_MsgCertificateChainDepTest.java | 685 ++--- ...k_sbp_signing_MsgCertificateChainTest.java | 730 ++---- ...k_sbp_signing_MsgEcdsaCertificateTest.java | 1289 ++-------- ...sbp_signing_MsgEcdsaSignatureDepATest.java | 1300 ++-------- ...sbp_signing_MsgEcdsaSignatureDepBTest.java | 369 +-- ...eck_sbp_signing_MsgEcdsaSignatureTest.java | 369 +-- ..._signing_MsgEd25519CertificateDepTest.java | 558 +--- ...p_signing_MsgEd25519SignatureDepATest.java | 646 +---- ...p_signing_MsgEd25519SignatureDepBTest.java | 656 +---- ...check_sbp_signing_signing_structsTest.java | 16 +- ...k_sbp_soln_meta_soln_meta_structsTest.java | 17 +- ...sbp_solution_meta_MsgSolnMetaDepATest.java | 1256 ++------- ...eck_sbp_solution_meta_MsgSolnMetaTest.java | 1255 ++------- ...to_check_sbp_ssr_MsgSsrCodeBiasesTest.java | 953 ++----- ...p_ssr_MsgSsrCodePhaseBiasesBoundsTest.java | 137 +- ..._sbp_ssr_MsgSsrGridDefinitionDepATest.java | 1289 ++-------- ...ssr_MsgSsrGriddedCorrectionBoundsTest.java | 271 +- ...p_ssr_MsgSsrGriddedCorrectionDepATest.java | 1076 ++------ ..._MsgSsrGriddedCorrectionNoStdDepATest.java | 1031 ++------ ...k_sbp_ssr_MsgSsrGriddedCorrectionTest.java | 1067 ++------ ...MsgSsrOrbitClockBoundsDegradationTest.java | 155 +- ...ck_sbp_ssr_MsgSsrOrbitClockBoundsTest.java | 136 +- ...heck_sbp_ssr_MsgSsrOrbitClockDepATest.java | 137 +- ...to_check_sbp_ssr_MsgSsrOrbitClockTest.java | 142 +- ...o_check_sbp_ssr_MsgSsrPhaseBiasesTest.java | 922 ++----- ...ck_sbp_ssr_MsgSsrSatelliteApcDepATest.java | 1034 ++------ ..._check_sbp_ssr_MsgSsrSatelliteApcTest.java | 199 +- ..._sbp_ssr_MsgSsrStecCorrectionDepATest.java | 918 ++----- ...k_sbp_ssr_MsgSsrStecCorrectionDepTest.java | 891 ++----- ...heck_sbp_ssr_MsgSsrStecCorrectionTest.java | 128 +- ..._sbp_ssr_MsgSsrTileDefinitionDepATest.java | 86 +- ..._sbp_ssr_MsgSsrTileDefinitionDepBTest.java | 91 +- ...heck_sbp_ssr_MsgSsrTileDefinitionTest.java | 84 +- .../auto_check_sbp_ssr_ssr_structsTest.java | 16 +- ...sbp_system_MsgCsacTelemetryLabelsTest.java | 33 +- ...check_sbp_system_MsgCsacTelemetryTest.java | 43 +- ...o_check_sbp_system_MsgDgnssStatusTest.java | 51 +- ...heck_sbp_system_MsgGnssTimeOffsetTest.java | 52 +- ...uto_check_sbp_system_MsgGroupMetaTest.java | 141 +- ...uto_check_sbp_system_MsgHeartbeatTest.java | 48 +- ...uto_check_sbp_system_MsgInsStatusTest.java | 33 +- ...to_check_sbp_system_MsgInsUpdatesTest.java | 61 +- .../auto_check_sbp_system_MsgPpsTimeTest.java | 44 +- ...heck_sbp_system_MsgSensorAidEventTest.java | 73 +- .../auto_check_sbp_system_MsgStartupTest.java | 61 +- ...check_sbp_system_MsgStatusJournalTest.java | 143 +- ..._check_sbp_system_MsgStatusReportTest.java | 1016 ++------ ...o_check_sbp_system_system_structsTest.java | 16 +- ...auto_check_sbp_telemetry_MsgTelSvTest.java | 85 +- ...sbp_telemetry_acquisition_structsTest.java | 17 +- ...k_sbp_telemetry_telemetry_structsTest.java | 17 +- ..._sbp_tracking_MsgMeasurementStateTest.java | 1211 ++------- ...ck_sbp_tracking_MsgTrackingIqDepATest.java | 71 +- ...ck_sbp_tracking_MsgTrackingIqDepBTest.java | 88 +- ..._check_sbp_tracking_MsgTrackingIqTest.java | 79 +- ...sbp_tracking_MsgTrackingStateDepBTest.java | 726 +----- ...king_MsgTrackingStateDetailedDepATest.java | 183 +- ...cking_MsgTrackingStateDetailedDepTest.java | 788 ++---- ...eck_sbp_tracking_MsgTrackingStateTest.java | 2282 ++++------------- ...sbp_tracking_MsgtrackingStateDepATest.java | 654 ++--- ...eck_sbp_tracking_tracking_structsTest.java | 17 +- .../auto_check_sbp_user_MsgUserDataTest.java | 1303 ++-------- ...uto_check_sbp_vehicle_MsgOdometryTest.java | 39 +- ...to_check_sbp_vehicle_MsgWheeltickTest.java | 45 +- javascript/sbp/integrity.js | 6 +- jsonschema/MsgSsrFlagHighLevel.json | 36 +- kaitai/ksy/integrity.ksy | 20 +- kaitai/perl/KaitaiSbp/Integrity.pm | 6 +- ..._check_sbp_integrity_MsgSsrFlagHighLevel.t | 48 +- kaitai/python/kaitai_sbp/integrity.py | 18 +- ...check_sbp_integrity_MsgSsrFlagHighLevel.py | 48 +- proto/integrity.proto | 2 +- sbpjson/elm/SbpJson.elm | 4 +- sbpjson/typescript/SbpJson.ts | 4 +- 567 files changed, 22533 insertions(+), 56313 deletions(-) diff --git a/docs/sbp.pdf b/docs/sbp.pdf index 5cdc5a75fcc343969db00b7c620481c79c93ffb0..3cace5b8cbe8849d6594e70a8df73e7329b06633 100644 GIT binary patch delta 44251 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

+d4Thg(qR;Cm}}t(0S* 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 B`qlsd delta 44093 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 diff --git a/java/src/com/swiftnav/sbp/acquisition/AcqSvProfile.java b/java/src/com/swiftnav/sbp/acquisition/AcqSvProfile.java index f9e07353d..063d88e93 100644 --- a/java/src/com/swiftnav/sbp/acquisition/AcqSvProfile.java +++ b/java/src/com/swiftnav/sbp/acquisition/AcqSvProfile.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.acquisition; // This file was auto-generated from yaml/swiftnav/sbp/acquisition.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class AcqSvProfile extends SBPStruct { - + /** SV search job type (deep, fallback, etc) */ public int job_type; - + /** Acquisition status 1 is Success, 0 is Failure */ public int status; - + /** CN0 value. Only valid if status is '1' */ public int cn0; - + /** Acquisition integration time */ public int int_time; - + /** GNSS signal for which acquisition was attempted */ public GnssSignal sid; - + /** Acq frequency bin width */ public int bin_width; - + /** Timestamp of the job complete event */ public long timestamp; - + /** Time spent to search for sid.code */ public long time_spent; - + /** Doppler range lowest frequency */ public int cf_min; - + /** Doppler range highest frequency */ public int cf_max; - + /** Doppler value of detected peak. Only valid if status is '1' */ public int cf; - + /** Codephase of detected peak. Only valid if status is '1' */ public long cp; + - public AcqSvProfile() {} + public AcqSvProfile () {} @Override public AcqSvProfile parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/acquisition/AcqSvProfileDep.java b/java/src/com/swiftnav/sbp/acquisition/AcqSvProfileDep.java index f2a4557f0..7d3412e7b 100644 --- a/java/src/com/swiftnav/sbp/acquisition/AcqSvProfileDep.java +++ b/java/src/com/swiftnav/sbp/acquisition/AcqSvProfileDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.acquisition; // This file was auto-generated from yaml/swiftnav/sbp/acquisition.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class AcqSvProfileDep extends SBPStruct { - + /** SV search job type (deep, fallback, etc) */ public int job_type; - + /** Acquisition status 1 is Success, 0 is Failure */ public int status; - + /** CN0 value. Only valid if status is '1' */ public int cn0; - + /** Acquisition integration time */ public int int_time; - + /** GNSS signal for which acquisition was attempted */ public GnssSignalDep sid; - + /** Acq frequency bin width */ public int bin_width; - + /** Timestamp of the job complete event */ public long timestamp; - + /** Time spent to search for sid.code */ public long time_spent; - + /** Doppler range lowest frequency */ public int cf_min; - + /** Doppler range highest frequency */ public int cf_max; - + /** Doppler value of detected peak. Only valid if status is '1' */ public int cf; - + /** Codephase of detected peak. Only valid if status is '1' */ public long cp; + - public AcqSvProfileDep() {} + public AcqSvProfileDep () {} @Override public AcqSvProfileDep parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/acquisition/MsgAcqResult.java b/java/src/com/swiftnav/sbp/acquisition/MsgAcqResult.java index 24e49abbd..feaa1245b 100644 --- a/java/src/com/swiftnav/sbp/acquisition/MsgAcqResult.java +++ b/java/src/com/swiftnav/sbp/acquisition/MsgAcqResult.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,57 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.acquisition; // This file was auto-generated from yaml/swiftnav/sbp/acquisition.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_ACQ_RESULT (0x002F). + +/** SBP class for message MSG_ACQ_RESULT (0x002F). * - *

You can have MSG_ACQ_RESULT inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_ACQ_RESULT inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message describes the results from an attempted GPS signal acquisition search for a - * satellite PRN over a code phase/carrier frequency range. It contains the parameters of the point - * in the acquisition search space with the best carrier-to-noise (CN/0) ratio. - */ + * This message describes the results from an attempted GPS signal acquisition + * search for a satellite PRN over a code phase/carrier frequency range. It + * contains the parameters of the point in the acquisition search space with + * the best carrier-to-noise (CN/0) ratio. */ + public class MsgAcqResult extends SBPMessage { public static final int TYPE = 0x002F; + /** CN/0 of best point */ public float cn0; - + /** Code phase of best point */ public float cp; - + /** Carrier frequency of best point */ public float cf; - + /** GNSS signal for which acquisition was attempted */ public GnssSignal sid; + - public MsgAcqResult(int sender) { - super(sender, TYPE); - } - - public MsgAcqResult() { - super(TYPE); - } - - public MsgAcqResult(SBPMessage msg) throws SBPBinaryException { + public MsgAcqResult (int sender) { super(sender, TYPE); } + public MsgAcqResult () { super(TYPE); } + public MsgAcqResult (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAcqResult, expected 47, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAcqResult, expected 47, actual " + msg.type); } @Override @@ -65,7 +68,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cn0 = parser.getFloat(); cp = parser.getFloat(); cf = parser.getFloat(); - sid = new GnssSignal().parse(parser); + sid = new GnssSignal().parse(parser); } @Override @@ -73,7 +76,7 @@ protected void build(Builder builder) { builder.putFloat(cn0); builder.putFloat(cp); builder.putFloat(cf); - sid.build(builder); + sid.build(builder); } @Override diff --git a/java/src/com/swiftnav/sbp/acquisition/MsgAcqResultDepA.java b/java/src/com/swiftnav/sbp/acquisition/MsgAcqResultDepA.java index e82015386..4c32d947b 100644 --- a/java/src/com/swiftnav/sbp/acquisition/MsgAcqResultDepA.java +++ b/java/src/com/swiftnav/sbp/acquisition/MsgAcqResultDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.acquisition; // This file was auto-generated from yaml/swiftnav/sbp/acquisition.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_ACQ_RESULT_DEP_A (0x0015). + +/** SBP class for message MSG_ACQ_RESULT_DEP_A (0x0015). * - *

You can have MSG_ACQ_RESULT_DEP_A inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_ACQ_RESULT_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgAcqResultDepA extends SBPMessage { public static final int TYPE = 0x0015; - /** - * SNR of best point. Currently dimensionless, but will have units of dB Hz in the revision of - * this message. - */ + + /** SNR of best point. Currently dimensionless, but will have units of dB + * Hz in the revision of this message. */ public float snr; - + /** Code phase of best point */ public float cp; - + /** Carrier frequency of best point */ public float cf; - - /** PRN-1 identifier of the satellite signal for which acquisition was attempted */ + + /** PRN-1 identifier of the satellite signal for which acquisition was + * attempted */ public int prn; + - public MsgAcqResultDepA(int sender) { - super(sender, TYPE); - } - - public MsgAcqResultDepA() { - super(TYPE); - } - - public MsgAcqResultDepA(SBPMessage msg) throws SBPBinaryException { + public MsgAcqResultDepA (int sender) { super(sender, TYPE); } + public MsgAcqResultDepA () { super(TYPE); } + public MsgAcqResultDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAcqResultDepA, expected 21, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAcqResultDepA, expected 21, actual " + msg.type); } @Override @@ -66,7 +67,7 @@ protected void parse(Parser parser) throws SBPBinaryException { snr = parser.getFloat(); cp = parser.getFloat(); cf = parser.getFloat(); - prn = parser.getU8(); + prn = parser.getU8(); } @Override @@ -74,7 +75,7 @@ protected void build(Builder builder) { builder.putFloat(snr); builder.putFloat(cp); builder.putFloat(cf); - builder.putU8(prn); + builder.putU8(prn); } @Override diff --git a/java/src/com/swiftnav/sbp/acquisition/MsgAcqResultDepB.java b/java/src/com/swiftnav/sbp/acquisition/MsgAcqResultDepB.java index 101635618..f5f17cdcb 100644 --- a/java/src/com/swiftnav/sbp/acquisition/MsgAcqResultDepB.java +++ b/java/src/com/swiftnav/sbp/acquisition/MsgAcqResultDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,55 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.acquisition; // This file was auto-generated from yaml/swiftnav/sbp/acquisition.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_ACQ_RESULT_DEP_B (0x0014). + +/** SBP class for message MSG_ACQ_RESULT_DEP_B (0x0014). * - *

You can have MSG_ACQ_RESULT_DEP_B inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_ACQ_RESULT_DEP_B inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgAcqResultDepB extends SBPMessage { public static final int TYPE = 0x0014; - /** - * SNR of best point. Currently in arbitrary SNR points, but will be in units of dB Hz in a - * later revision of this message. - */ + + /** SNR of best point. Currently in arbitrary SNR points, but will be in + * units of dB Hz in a later revision of this message. */ public float snr; - + /** Code phase of best point */ public float cp; - + /** Carrier frequency of best point */ public float cf; - + /** GNSS signal for which acquisition was attempted */ public GnssSignalDep sid; + - public MsgAcqResultDepB(int sender) { - super(sender, TYPE); - } - - public MsgAcqResultDepB() { - super(TYPE); - } - - public MsgAcqResultDepB(SBPMessage msg) throws SBPBinaryException { + public MsgAcqResultDepB (int sender) { super(sender, TYPE); } + public MsgAcqResultDepB () { super(TYPE); } + public MsgAcqResultDepB (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAcqResultDepB, expected 20, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAcqResultDepB, expected 20, actual " + msg.type); } @Override @@ -66,7 +66,7 @@ protected void parse(Parser parser) throws SBPBinaryException { snr = parser.getFloat(); cp = parser.getFloat(); cf = parser.getFloat(); - sid = new GnssSignalDep().parse(parser); + sid = new GnssSignalDep().parse(parser); } @Override @@ -74,7 +74,7 @@ protected void build(Builder builder) { builder.putFloat(snr); builder.putFloat(cp); builder.putFloat(cf); - sid.build(builder); + sid.build(builder); } @Override diff --git a/java/src/com/swiftnav/sbp/acquisition/MsgAcqResultDepC.java b/java/src/com/swiftnav/sbp/acquisition/MsgAcqResultDepC.java index d6a51f5c0..7a0a06982 100644 --- a/java/src/com/swiftnav/sbp/acquisition/MsgAcqResultDepC.java +++ b/java/src/com/swiftnav/sbp/acquisition/MsgAcqResultDepC.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,53 +9,54 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.acquisition; // This file was auto-generated from yaml/swiftnav/sbp/acquisition.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_ACQ_RESULT_DEP_C (0x001F). + +/** SBP class for message MSG_ACQ_RESULT_DEP_C (0x001F). * - *

You can have MSG_ACQ_RESULT_DEP_C inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_ACQ_RESULT_DEP_C inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgAcqResultDepC extends SBPMessage { public static final int TYPE = 0x001F; + /** CN/0 of best point */ public float cn0; - + /** Code phase of best point */ public float cp; - + /** Carrier frequency of best point */ public float cf; - + /** GNSS signal for which acquisition was attempted */ public GnssSignalDep sid; + - public MsgAcqResultDepC(int sender) { - super(sender, TYPE); - } - - public MsgAcqResultDepC() { - super(TYPE); - } - - public MsgAcqResultDepC(SBPMessage msg) throws SBPBinaryException { + public MsgAcqResultDepC (int sender) { super(sender, TYPE); } + public MsgAcqResultDepC () { super(TYPE); } + public MsgAcqResultDepC (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAcqResultDepC, expected 31, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAcqResultDepC, expected 31, actual " + msg.type); } @Override @@ -63,7 +65,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cn0 = parser.getFloat(); cp = parser.getFloat(); cf = parser.getFloat(); - sid = new GnssSignalDep().parse(parser); + sid = new GnssSignalDep().parse(parser); } @Override @@ -71,7 +73,7 @@ protected void build(Builder builder) { builder.putFloat(cn0); builder.putFloat(cp); builder.putFloat(cf); - sid.build(builder); + sid.build(builder); } @Override diff --git a/java/src/com/swiftnav/sbp/acquisition/MsgAcqSvProfile.java b/java/src/com/swiftnav/sbp/acquisition/MsgAcqSvProfile.java index 3993b57a3..9bfae3f3b 100644 --- a/java/src/com/swiftnav/sbp/acquisition/MsgAcqSvProfile.java +++ b/java/src/com/swiftnav/sbp/acquisition/MsgAcqSvProfile.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,57 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.acquisition; // This file was auto-generated from yaml/swiftnav/sbp/acquisition.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ACQ_SV_PROFILE (0x002E). +/** SBP class for message MSG_ACQ_SV_PROFILE (0x002E). * - *

You can have MSG_ACQ_SV_PROFILE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_ACQ_SV_PROFILE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The message describes all SV profiles during acquisition time. The message is used to debug - * and measure the performance. - */ + * The message describes all SV profiles during acquisition time. The message + * is used to debug and measure the performance. */ + public class MsgAcqSvProfile extends SBPMessage { public static final int TYPE = 0x002E; + /** SV profiles during acquisition time */ public AcqSvProfile[] acq_sv_profile; + - public MsgAcqSvProfile(int sender) { - super(sender, TYPE); - } - - public MsgAcqSvProfile() { - super(TYPE); - } - - public MsgAcqSvProfile(SBPMessage msg) throws SBPBinaryException { + public MsgAcqSvProfile (int sender) { super(sender, TYPE); } + public MsgAcqSvProfile () { super(TYPE); } + public MsgAcqSvProfile (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAcqSvProfile, expected 46, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAcqSvProfile, expected 46, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - acq_sv_profile = parser.getArray(AcqSvProfile.class); + acq_sv_profile = parser.getArray(AcqSvProfile.class); } @Override protected void build(Builder builder) { - builder.putArray(acq_sv_profile); + builder.putArray(acq_sv_profile); } @Override diff --git a/java/src/com/swiftnav/sbp/acquisition/MsgAcqSvProfileDep.java b/java/src/com/swiftnav/sbp/acquisition/MsgAcqSvProfileDep.java index 17f726dfb..8bb985634 100644 --- a/java/src/com/swiftnav/sbp/acquisition/MsgAcqSvProfileDep.java +++ b/java/src/com/swiftnav/sbp/acquisition/MsgAcqSvProfileDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.acquisition; // This file was auto-generated from yaml/swiftnav/sbp/acquisition.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ACQ_SV_PROFILE_DEP (0x001E). +/** SBP class for message MSG_ACQ_SV_PROFILE_DEP (0x001E). * - *

You can have MSG_ACQ_SV_PROFILE_DEP inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_ACQ_SV_PROFILE_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgAcqSvProfileDep extends SBPMessage { public static final int TYPE = 0x001E; + /** SV profiles during acquisition time */ public AcqSvProfileDep[] acq_sv_profile; + - public MsgAcqSvProfileDep(int sender) { - super(sender, TYPE); - } - - public MsgAcqSvProfileDep() { - super(TYPE); - } - - public MsgAcqSvProfileDep(SBPMessage msg) throws SBPBinaryException { + public MsgAcqSvProfileDep (int sender) { super(sender, TYPE); } + public MsgAcqSvProfileDep () { super(TYPE); } + public MsgAcqSvProfileDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAcqSvProfileDep, expected 30, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAcqSvProfileDep, expected 30, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - acq_sv_profile = parser.getArray(AcqSvProfileDep.class); + acq_sv_profile = parser.getArray(AcqSvProfileDep.class); } @Override protected void build(Builder builder) { - builder.putArray(acq_sv_profile); + builder.putArray(acq_sv_profile); } @Override diff --git a/java/src/com/swiftnav/sbp/bootload/MsgBootloaderHandshakeDepA.java b/java/src/com/swiftnav/sbp/bootload/MsgBootloaderHandshakeDepA.java index a911c92e2..47d605885 100644 --- a/java/src/com/swiftnav/sbp/bootload/MsgBootloaderHandshakeDepA.java +++ b/java/src/com/swiftnav/sbp/bootload/MsgBootloaderHandshakeDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,55 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.bootload; // This file was auto-generated from yaml/swiftnav/sbp/bootload.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_BOOTLOADER_HANDSHAKE_DEP_A (0x00B0). +/** SBP class for message MSG_BOOTLOADER_HANDSHAKE_DEP_A (0x00B0). * - *

You can have MSG_BOOTLOADER_HANDSHAKE_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_BOOTLOADER_HANDSHAKE_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgBootloaderHandshakeDepA extends SBPMessage { public static final int TYPE = 0x00B0; + /** Version number string (not NULL terminated) */ public int[] handshake; + - public MsgBootloaderHandshakeDepA(int sender) { - super(sender, TYPE); - } - - public MsgBootloaderHandshakeDepA() { - super(TYPE); - } - - public MsgBootloaderHandshakeDepA(SBPMessage msg) throws SBPBinaryException { + public MsgBootloaderHandshakeDepA (int sender) { super(sender, TYPE); } + public MsgBootloaderHandshakeDepA () { super(TYPE); } + public MsgBootloaderHandshakeDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgBootloaderHandshakeDepA, expected 176, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgBootloaderHandshakeDepA, expected 176, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - handshake = parser.getArrayofU8(); + handshake = parser.getArrayofU8(); } @Override protected void build(Builder builder) { - builder.putArrayofU8(handshake); + builder.putArrayofU8(handshake); } @Override diff --git a/java/src/com/swiftnav/sbp/bootload/MsgBootloaderHandshakeReq.java b/java/src/com/swiftnav/sbp/bootload/MsgBootloaderHandshakeReq.java index c64e581d1..0f2c10bde 100644 --- a/java/src/com/swiftnav/sbp/bootload/MsgBootloaderHandshakeReq.java +++ b/java/src/com/swiftnav/sbp/bootload/MsgBootloaderHandshakeReq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,42 +9,43 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.bootload; // This file was auto-generated from yaml/swiftnav/sbp/bootload.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_BOOTLOADER_HANDSHAKE_REQ (0x00B3). +/** SBP class for message MSG_BOOTLOADER_HANDSHAKE_REQ (0x00B3). * - *

You can have MSG_BOOTLOADER_HANDSHAKE_REQ inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_BOOTLOADER_HANDSHAKE_REQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The handshake message request from the host establishes a handshake between the device - * bootloader and the host. The response from the device is MSG_BOOTLOADER_HANDSHAKE_RESP. - */ + * The handshake message request from the host establishes a handshake between + * the device bootloader and the host. The response from the device is + * MSG_BOOTLOADER_HANDSHAKE_RESP. */ + public class MsgBootloaderHandshakeReq extends SBPMessage { public static final int TYPE = 0x00B3; - public MsgBootloaderHandshakeReq(int sender) { - super(sender, TYPE); - } - - public MsgBootloaderHandshakeReq() { - super(TYPE); - } + - public MsgBootloaderHandshakeReq(SBPMessage msg) throws SBPBinaryException { + public MsgBootloaderHandshakeReq (int sender) { super(sender, TYPE); } + public MsgBootloaderHandshakeReq () { super(TYPE); } + public MsgBootloaderHandshakeReq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgBootloaderHandshakeReq, expected 179, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgBootloaderHandshakeReq, expected 179, actual " + msg.type); } @Override diff --git a/java/src/com/swiftnav/sbp/bootload/MsgBootloaderHandshakeResp.java b/java/src/com/swiftnav/sbp/bootload/MsgBootloaderHandshakeResp.java index 78b685b86..11c109b69 100644 --- a/java/src/com/swiftnav/sbp/bootload/MsgBootloaderHandshakeResp.java +++ b/java/src/com/swiftnav/sbp/bootload/MsgBootloaderHandshakeResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,62 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.bootload; // This file was auto-generated from yaml/swiftnav/sbp/bootload.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_BOOTLOADER_HANDSHAKE_RESP (0x00B4). +/** SBP class for message MSG_BOOTLOADER_HANDSHAKE_RESP (0x00B4). * - *

You can have MSG_BOOTLOADER_HANDSHAKE_RESP inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_BOOTLOADER_HANDSHAKE_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The handshake message response from the device establishes a handshake between the device - * bootloader and the host. The request from the host is MSG_BOOTLOADER_HANDSHAKE_REQ. The payload - * contains the bootloader version number and the SBP protocol version number. - */ + * The handshake message response from the device establishes a handshake + * between the device bootloader and the host. The request from the host is + * MSG_BOOTLOADER_HANDSHAKE_REQ. The payload contains the bootloader version + * number and the SBP protocol version number. */ + public class MsgBootloaderHandshakeResp extends SBPMessage { public static final int TYPE = 0x00B4; + /** Bootloader flags */ public long flags; - + /** Bootloader version number */ public String version; + - public MsgBootloaderHandshakeResp(int sender) { - super(sender, TYPE); - } - - public MsgBootloaderHandshakeResp() { - super(TYPE); - } - - public MsgBootloaderHandshakeResp(SBPMessage msg) throws SBPBinaryException { + public MsgBootloaderHandshakeResp (int sender) { super(sender, TYPE); } + public MsgBootloaderHandshakeResp () { super(TYPE); } + public MsgBootloaderHandshakeResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgBootloaderHandshakeResp, expected 180, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgBootloaderHandshakeResp, expected 180, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ flags = parser.getU32(); - version = parser.getString(); + version = parser.getString(); } @Override protected void build(Builder builder) { builder.putU32(flags); - builder.putString(version); + builder.putString(version); } @Override diff --git a/java/src/com/swiftnav/sbp/bootload/MsgBootloaderJumpToApp.java b/java/src/com/swiftnav/sbp/bootload/MsgBootloaderJumpToApp.java index d2dcc4c74..34916078b 100644 --- a/java/src/com/swiftnav/sbp/bootload/MsgBootloaderJumpToApp.java +++ b/java/src/com/swiftnav/sbp/bootload/MsgBootloaderJumpToApp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,54 +9,55 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.bootload; // This file was auto-generated from yaml/swiftnav/sbp/bootload.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_BOOTLOADER_JUMP_TO_APP (0x00B1). +/** SBP class for message MSG_BOOTLOADER_JUMP_TO_APP (0x00B1). * - *

You can have MSG_BOOTLOADER_JUMP_TO_APP inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_BOOTLOADER_JUMP_TO_APP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The host initiates the bootloader to jump to the application. - */ + * The host initiates the bootloader to jump to the application. */ + public class MsgBootloaderJumpToApp extends SBPMessage { public static final int TYPE = 0x00B1; + /** Ignored by the device */ public int jump; + - public MsgBootloaderJumpToApp(int sender) { - super(sender, TYPE); - } - - public MsgBootloaderJumpToApp() { - super(TYPE); - } - - public MsgBootloaderJumpToApp(SBPMessage msg) throws SBPBinaryException { + public MsgBootloaderJumpToApp (int sender) { super(sender, TYPE); } + public MsgBootloaderJumpToApp () { super(TYPE); } + public MsgBootloaderJumpToApp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgBootloaderJumpToApp, expected 177, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgBootloaderJumpToApp, expected 177, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - jump = parser.getU8(); + jump = parser.getU8(); } @Override protected void build(Builder builder) { - builder.putU8(jump); + builder.putU8(jump); } @Override diff --git a/java/src/com/swiftnav/sbp/bootload/MsgNapDeviceDnaReq.java b/java/src/com/swiftnav/sbp/bootload/MsgNapDeviceDnaReq.java index cb95820bc..fb955575a 100644 --- a/java/src/com/swiftnav/sbp/bootload/MsgNapDeviceDnaReq.java +++ b/java/src/com/swiftnav/sbp/bootload/MsgNapDeviceDnaReq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,43 +9,46 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.bootload; // This file was auto-generated from yaml/swiftnav/sbp/bootload.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_NAP_DEVICE_DNA_REQ (0x00DE). +/** SBP class for message MSG_NAP_DEVICE_DNA_REQ (0x00DE). * - *

You can have MSG_NAP_DEVICE_DNA_REQ inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_NAP_DEVICE_DNA_REQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The device message from the host reads a unique device identifier from the SwiftNAP, an FPGA. - * The host requests the ID by sending a MSG_NAP_DEVICE_DNA_REQ message. The device responds with a - * MSG_NAP_DEVICE_DNA_RESP message with the device ID in the payload. Note that this ID is tied to - * the FPGA, and not related to the Piksi's serial number. - */ + * The device message from the host reads a unique device identifier from the + * SwiftNAP, an FPGA. The host requests the ID by sending a + * MSG_NAP_DEVICE_DNA_REQ message. The device responds with a + * MSG_NAP_DEVICE_DNA_RESP message with the device ID in the payload. Note + * that this ID is tied to the FPGA, and not related to the Piksi's serial + * number. */ + public class MsgNapDeviceDnaReq extends SBPMessage { public static final int TYPE = 0x00DE; - public MsgNapDeviceDnaReq(int sender) { - super(sender, TYPE); - } - - public MsgNapDeviceDnaReq() { - super(TYPE); - } + - public MsgNapDeviceDnaReq(SBPMessage msg) throws SBPBinaryException { + public MsgNapDeviceDnaReq (int sender) { super(sender, TYPE); } + public MsgNapDeviceDnaReq () { super(TYPE); } + public MsgNapDeviceDnaReq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgNapDeviceDnaReq, expected 222, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgNapDeviceDnaReq, expected 222, actual " + msg.type); } @Override diff --git a/java/src/com/swiftnav/sbp/bootload/MsgNapDeviceDnaResp.java b/java/src/com/swiftnav/sbp/bootload/MsgNapDeviceDnaResp.java index a6ae4a76c..42e375802 100644 --- a/java/src/com/swiftnav/sbp/bootload/MsgNapDeviceDnaResp.java +++ b/java/src/com/swiftnav/sbp/bootload/MsgNapDeviceDnaResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,58 +9,61 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.bootload; // This file was auto-generated from yaml/swiftnav/sbp/bootload.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_NAP_DEVICE_DNA_RESP (0x00DD). +/** SBP class for message MSG_NAP_DEVICE_DNA_RESP (0x00DD). * - *

You can have MSG_NAP_DEVICE_DNA_RESP inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_NAP_DEVICE_DNA_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The device message from the host reads a unique device identifier from the SwiftNAP, an FPGA. - * The host requests the ID by sending a MSG_NAP_DEVICE_DNA_REQ message. The device responds with a - * MSG_NAP_DEVICE_DNA_RESP message with the device ID in the payload. Note that this ID is tied to - * the FPGA, and not related to the Piksi's serial number. - */ + * The device message from the host reads a unique device identifier from the + * SwiftNAP, an FPGA. The host requests the ID by sending a + * MSG_NAP_DEVICE_DNA_REQ message. The device responds with a + * MSG_NAP_DEVICE_DNA_RESP message with the device ID in the payload. Note + * that this ID is tied to the FPGA, and not related to the Piksi's serial + * number. */ + public class MsgNapDeviceDnaResp extends SBPMessage { public static final int TYPE = 0x00DD; - /** 57-bit SwiftNAP FPGA Device ID. Remaining bits are padded on the right. */ + + /** 57-bit SwiftNAP FPGA Device ID. Remaining bits are padded on the + * right. */ public int[] dna; + - public MsgNapDeviceDnaResp(int sender) { - super(sender, TYPE); - } - - public MsgNapDeviceDnaResp() { - super(TYPE); - } - - public MsgNapDeviceDnaResp(SBPMessage msg) throws SBPBinaryException { + public MsgNapDeviceDnaResp (int sender) { super(sender, TYPE); } + public MsgNapDeviceDnaResp () { super(TYPE); } + public MsgNapDeviceDnaResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgNapDeviceDnaResp, expected 221, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgNapDeviceDnaResp, expected 221, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - dna = parser.getArrayofU8(8); + dna = parser.getArrayofU8(8); } @Override protected void build(Builder builder) { - builder.putArrayofU8(dna, 8); + builder.putArrayofU8(dna, 8); } @Override diff --git a/java/src/com/swiftnav/sbp/client/MessageTable.java b/java/src/com/swiftnav/sbp/client/MessageTable.java index 098d3d731..31bed9926 100644 --- a/java/src/com/swiftnav/sbp/client/MessageTable.java +++ b/java/src/com/swiftnav/sbp/client/MessageTable.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -10,246 +11,247 @@ */ package com.swiftnav.sbp.client; - import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPMessage.Builder; +import com.swiftnav.sbp.SBPMessage.Parser; import com.swiftnav.sbp.acquisition.MsgAcqResult; -import com.swiftnav.sbp.acquisition.MsgAcqResultDepA; -import com.swiftnav.sbp.acquisition.MsgAcqResultDepB; import com.swiftnav.sbp.acquisition.MsgAcqResultDepC; +import com.swiftnav.sbp.acquisition.MsgAcqResultDepB; +import com.swiftnav.sbp.acquisition.MsgAcqResultDepA; import com.swiftnav.sbp.acquisition.MsgAcqSvProfile; import com.swiftnav.sbp.acquisition.MsgAcqSvProfileDep; -import com.swiftnav.sbp.bootload.MsgBootloaderHandshakeDepA; import com.swiftnav.sbp.bootload.MsgBootloaderHandshakeReq; import com.swiftnav.sbp.bootload.MsgBootloaderHandshakeResp; import com.swiftnav.sbp.bootload.MsgBootloaderJumpToApp; import com.swiftnav.sbp.bootload.MsgNapDeviceDnaReq; import com.swiftnav.sbp.bootload.MsgNapDeviceDnaResp; +import com.swiftnav.sbp.bootload.MsgBootloaderHandshakeDepA; import com.swiftnav.sbp.ext_events.MsgExtEvent; -import com.swiftnav.sbp.file_io.MsgFileioConfigReq; -import com.swiftnav.sbp.file_io.MsgFileioConfigResp; -import com.swiftnav.sbp.file_io.MsgFileioReadDirReq; -import com.swiftnav.sbp.file_io.MsgFileioReadDirResp; import com.swiftnav.sbp.file_io.MsgFileioReadReq; import com.swiftnav.sbp.file_io.MsgFileioReadResp; +import com.swiftnav.sbp.file_io.MsgFileioReadDirReq; +import com.swiftnav.sbp.file_io.MsgFileioReadDirResp; import com.swiftnav.sbp.file_io.MsgFileioRemove; import com.swiftnav.sbp.file_io.MsgFileioWriteReq; import com.swiftnav.sbp.file_io.MsgFileioWriteResp; -import com.swiftnav.sbp.flash.MsgFlashDone; -import com.swiftnav.sbp.flash.MsgFlashErase; +import com.swiftnav.sbp.file_io.MsgFileioConfigReq; +import com.swiftnav.sbp.file_io.MsgFileioConfigResp; import com.swiftnav.sbp.flash.MsgFlashProgram; +import com.swiftnav.sbp.flash.MsgFlashDone; import com.swiftnav.sbp.flash.MsgFlashReadReq; import com.swiftnav.sbp.flash.MsgFlashReadResp; -import com.swiftnav.sbp.flash.MsgM25FlashWriteStatus; +import com.swiftnav.sbp.flash.MsgFlashErase; import com.swiftnav.sbp.flash.MsgStmFlashLockSector; import com.swiftnav.sbp.flash.MsgStmFlashUnlockSector; import com.swiftnav.sbp.flash.MsgStmUniqueIdReq; import com.swiftnav.sbp.flash.MsgStmUniqueIdResp; +import com.swiftnav.sbp.flash.MsgM25FlashWriteStatus; +import com.swiftnav.sbp.imu.MsgImuRaw; import com.swiftnav.sbp.imu.MsgImuAux; import com.swiftnav.sbp.imu.MsgImuComp; -import com.swiftnav.sbp.imu.MsgImuRaw; -import com.swiftnav.sbp.integrity.MsgAcknowledge; -import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevel; import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevelDepA; -import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPointSatLos; -import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPoints; -import com.swiftnav.sbp.integrity.MsgSsrFlagIonoTileSatLos; +import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevel; import com.swiftnav.sbp.integrity.MsgSsrFlagSatellites; import com.swiftnav.sbp.integrity.MsgSsrFlagTropoGridPoints; -import com.swiftnav.sbp.linux.MsgLinuxCpuState; +import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPoints; +import com.swiftnav.sbp.integrity.MsgSsrFlagIonoTileSatLos; +import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPointSatLos; +import com.swiftnav.sbp.integrity.MsgAcknowledge; import com.swiftnav.sbp.linux.MsgLinuxCpuStateDepA; -import com.swiftnav.sbp.linux.MsgLinuxMemState; import com.swiftnav.sbp.linux.MsgLinuxMemStateDepA; -import com.swiftnav.sbp.linux.MsgLinuxProcessFdCount; -import com.swiftnav.sbp.linux.MsgLinuxProcessFdSummary; +import com.swiftnav.sbp.linux.MsgLinuxSysStateDepA; import com.swiftnav.sbp.linux.MsgLinuxProcessSocketCounts; import com.swiftnav.sbp.linux.MsgLinuxProcessSocketQueues; import com.swiftnav.sbp.linux.MsgLinuxSocketUsage; +import com.swiftnav.sbp.linux.MsgLinuxProcessFdCount; +import com.swiftnav.sbp.linux.MsgLinuxProcessFdSummary; +import com.swiftnav.sbp.linux.MsgLinuxCpuState; +import com.swiftnav.sbp.linux.MsgLinuxMemState; import com.swiftnav.sbp.linux.MsgLinuxSysState; -import com.swiftnav.sbp.linux.MsgLinuxSysStateDepA; -import com.swiftnav.sbp.logging.MsgFwd; import com.swiftnav.sbp.logging.MsgLog; +import com.swiftnav.sbp.logging.MsgFwd; import com.swiftnav.sbp.logging.MsgPrintDep; import com.swiftnav.sbp.mag.MsgMagRaw; -import com.swiftnav.sbp.navigation.MsgAgeCorrections; -import com.swiftnav.sbp.navigation.MsgBaselineECEF; -import com.swiftnav.sbp.navigation.MsgBaselineECEFDepA; -import com.swiftnav.sbp.navigation.MsgBaselineHeadingDepA; -import com.swiftnav.sbp.navigation.MsgBaselineNED; -import com.swiftnav.sbp.navigation.MsgBaselineNEDDepA; -import com.swiftnav.sbp.navigation.MsgDops; -import com.swiftnav.sbp.navigation.MsgDopsDepA; import com.swiftnav.sbp.navigation.MsgGPSTime; -import com.swiftnav.sbp.navigation.MsgGPSTimeDepA; import com.swiftnav.sbp.navigation.MsgGPSTimeGnss; +import com.swiftnav.sbp.navigation.MsgUtcTime; +import com.swiftnav.sbp.navigation.MsgUtcTimeGnss; +import com.swiftnav.sbp.navigation.MsgDops; import com.swiftnav.sbp.navigation.MsgPosECEF; import com.swiftnav.sbp.navigation.MsgPosECEFCov; -import com.swiftnav.sbp.navigation.MsgPosECEFCovGnss; -import com.swiftnav.sbp.navigation.MsgPosECEFDepA; -import com.swiftnav.sbp.navigation.MsgPosECEFGnss; import com.swiftnav.sbp.navigation.MsgPosLLH; -import com.swiftnav.sbp.navigation.MsgPosLLHAcc; import com.swiftnav.sbp.navigation.MsgPosLLHCov; -import com.swiftnav.sbp.navigation.MsgPosLLHCovGnss; -import com.swiftnav.sbp.navigation.MsgPosLLHDepA; -import com.swiftnav.sbp.navigation.MsgPosLLHGnss; -import com.swiftnav.sbp.navigation.MsgPoseRelative; -import com.swiftnav.sbp.navigation.MsgProtectionLevel; -import com.swiftnav.sbp.navigation.MsgProtectionLevelDepA; -import com.swiftnav.sbp.navigation.MsgReferenceFrameParam; -import com.swiftnav.sbp.navigation.MsgUtcLeapSecond; -import com.swiftnav.sbp.navigation.MsgUtcTime; -import com.swiftnav.sbp.navigation.MsgUtcTimeGnss; -import com.swiftnav.sbp.navigation.MsgVelBody; -import com.swiftnav.sbp.navigation.MsgVelCog; +import com.swiftnav.sbp.navigation.MsgPosLLHAcc; +import com.swiftnav.sbp.navigation.MsgBaselineECEF; +import com.swiftnav.sbp.navigation.MsgBaselineNED; import com.swiftnav.sbp.navigation.MsgVelECEF; import com.swiftnav.sbp.navigation.MsgVelECEFCov; -import com.swiftnav.sbp.navigation.MsgVelECEFCovGnss; -import com.swiftnav.sbp.navigation.MsgVelECEFDepA; -import com.swiftnav.sbp.navigation.MsgVelECEFGnss; import com.swiftnav.sbp.navigation.MsgVelNED; import com.swiftnav.sbp.navigation.MsgVelNEDCov; +import com.swiftnav.sbp.navigation.MsgPosECEFGnss; +import com.swiftnav.sbp.navigation.MsgPosECEFCovGnss; +import com.swiftnav.sbp.navigation.MsgPosLLHGnss; +import com.swiftnav.sbp.navigation.MsgPosLLHCovGnss; +import com.swiftnav.sbp.navigation.MsgVelECEFGnss; +import com.swiftnav.sbp.navigation.MsgVelECEFCovGnss; +import com.swiftnav.sbp.navigation.MsgVelNEDGnss; import com.swiftnav.sbp.navigation.MsgVelNEDCovGnss; +import com.swiftnav.sbp.navigation.MsgVelBody; +import com.swiftnav.sbp.navigation.MsgVelCog; +import com.swiftnav.sbp.navigation.MsgAgeCorrections; +import com.swiftnav.sbp.navigation.MsgGPSTimeDepA; +import com.swiftnav.sbp.navigation.MsgDopsDepA; +import com.swiftnav.sbp.navigation.MsgPosECEFDepA; +import com.swiftnav.sbp.navigation.MsgPosLLHDepA; +import com.swiftnav.sbp.navigation.MsgBaselineECEFDepA; +import com.swiftnav.sbp.navigation.MsgBaselineNEDDepA; +import com.swiftnav.sbp.navigation.MsgVelECEFDepA; import com.swiftnav.sbp.navigation.MsgVelNEDDepA; -import com.swiftnav.sbp.navigation.MsgVelNEDGnss; +import com.swiftnav.sbp.navigation.MsgBaselineHeadingDepA; +import com.swiftnav.sbp.navigation.MsgProtectionLevelDepA; +import com.swiftnav.sbp.navigation.MsgProtectionLevel; +import com.swiftnav.sbp.navigation.MsgUtcLeapSecond; +import com.swiftnav.sbp.navigation.MsgReferenceFrameParam; +import com.swiftnav.sbp.navigation.MsgPoseRelative; import com.swiftnav.sbp.ndb.MsgNdbEvent; -import com.swiftnav.sbp.observation.MsgAlmanacGPS; -import com.swiftnav.sbp.observation.MsgAlmanacGPSDep; -import com.swiftnav.sbp.observation.MsgAlmanacGlo; -import com.swiftnav.sbp.observation.MsgAlmanacGloDep; -import com.swiftnav.sbp.observation.MsgBasePosECEF; +import com.swiftnav.sbp.observation.MsgObs; import com.swiftnav.sbp.observation.MsgBasePosLLH; -import com.swiftnav.sbp.observation.MsgEphemerisBds; -import com.swiftnav.sbp.observation.MsgEphemerisDepA; -import com.swiftnav.sbp.observation.MsgEphemerisDepB; -import com.swiftnav.sbp.observation.MsgEphemerisDepC; -import com.swiftnav.sbp.observation.MsgEphemerisDepD; -import com.swiftnav.sbp.observation.MsgEphemerisGPS; +import com.swiftnav.sbp.observation.MsgBasePosECEF; import com.swiftnav.sbp.observation.MsgEphemerisGPSDepE; import com.swiftnav.sbp.observation.MsgEphemerisGPSDepF; -import com.swiftnav.sbp.observation.MsgEphemerisGal; +import com.swiftnav.sbp.observation.MsgEphemerisGPS; +import com.swiftnav.sbp.observation.MsgEphemerisQzss; +import com.swiftnav.sbp.observation.MsgEphemerisBds; import com.swiftnav.sbp.observation.MsgEphemerisGalDepA; -import com.swiftnav.sbp.observation.MsgEphemerisGlo; +import com.swiftnav.sbp.observation.MsgEphemerisGal; +import com.swiftnav.sbp.observation.MsgEphemerisSbasDepA; import com.swiftnav.sbp.observation.MsgEphemerisGloDepA; +import com.swiftnav.sbp.observation.MsgEphemerisSbasDepB; +import com.swiftnav.sbp.observation.MsgEphemerisSbas; import com.swiftnav.sbp.observation.MsgEphemerisGloDepB; import com.swiftnav.sbp.observation.MsgEphemerisGloDepC; import com.swiftnav.sbp.observation.MsgEphemerisGloDepD; -import com.swiftnav.sbp.observation.MsgEphemerisQzss; -import com.swiftnav.sbp.observation.MsgEphemerisSbas; -import com.swiftnav.sbp.observation.MsgEphemerisSbasDepA; -import com.swiftnav.sbp.observation.MsgEphemerisSbasDepB; -import com.swiftnav.sbp.observation.MsgGloBiases; -import com.swiftnav.sbp.observation.MsgGnssCapb; -import com.swiftnav.sbp.observation.MsgGroupDelay; -import com.swiftnav.sbp.observation.MsgGroupDelayDepA; -import com.swiftnav.sbp.observation.MsgGroupDelayDepB; -import com.swiftnav.sbp.observation.MsgIono; -import com.swiftnav.sbp.observation.MsgObs; +import com.swiftnav.sbp.observation.MsgEphemerisGlo; +import com.swiftnav.sbp.observation.MsgEphemerisDepD; +import com.swiftnav.sbp.observation.MsgEphemerisDepA; +import com.swiftnav.sbp.observation.MsgEphemerisDepB; +import com.swiftnav.sbp.observation.MsgEphemerisDepC; import com.swiftnav.sbp.observation.MsgObsDepA; import com.swiftnav.sbp.observation.MsgObsDepB; import com.swiftnav.sbp.observation.MsgObsDepC; -import com.swiftnav.sbp.observation.MsgOsr; -import com.swiftnav.sbp.observation.MsgSvAzEl; +import com.swiftnav.sbp.observation.MsgIono; import com.swiftnav.sbp.observation.MsgSvConfigurationGPSDep; -import com.swiftnav.sbp.orientation.MsgAngularRate; +import com.swiftnav.sbp.observation.MsgGnssCapb; +import com.swiftnav.sbp.observation.MsgGroupDelayDepA; +import com.swiftnav.sbp.observation.MsgGroupDelayDepB; +import com.swiftnav.sbp.observation.MsgGroupDelay; +import com.swiftnav.sbp.observation.MsgAlmanacGPSDep; +import com.swiftnav.sbp.observation.MsgAlmanacGPS; +import com.swiftnav.sbp.observation.MsgAlmanacGloDep; +import com.swiftnav.sbp.observation.MsgAlmanacGlo; +import com.swiftnav.sbp.observation.MsgGloBiases; +import com.swiftnav.sbp.observation.MsgSvAzEl; +import com.swiftnav.sbp.observation.MsgOsr; import com.swiftnav.sbp.orientation.MsgBaselineHeading; -import com.swiftnav.sbp.orientation.MsgOrientEuler; import com.swiftnav.sbp.orientation.MsgOrientQuat; +import com.swiftnav.sbp.orientation.MsgOrientEuler; +import com.swiftnav.sbp.orientation.MsgAngularRate; import com.swiftnav.sbp.piksi.MsgAlmanac; -import com.swiftnav.sbp.piksi.MsgCellModemStatus; -import com.swiftnav.sbp.piksi.MsgCommandOutput; -import com.swiftnav.sbp.piksi.MsgCommandReq; -import com.swiftnav.sbp.piksi.MsgCommandResp; +import com.swiftnav.sbp.piksi.MsgSetTime; +import com.swiftnav.sbp.piksi.MsgReset; +import com.swiftnav.sbp.piksi.MsgResetDep; import com.swiftnav.sbp.piksi.MsgCwResults; import com.swiftnav.sbp.piksi.MsgCwStart; -import com.swiftnav.sbp.piksi.MsgDeviceMonitor; -import com.swiftnav.sbp.piksi.MsgFrontEndGain; -import com.swiftnav.sbp.piksi.MsgIarState; +import com.swiftnav.sbp.piksi.MsgResetFilters; import com.swiftnav.sbp.piksi.MsgInitBaseDep; +import com.swiftnav.sbp.piksi.MsgThreadState; +import com.swiftnav.sbp.piksi.MsgUartState; +import com.swiftnav.sbp.piksi.MsgUartStateDepa; +import com.swiftnav.sbp.piksi.MsgIarState; import com.swiftnav.sbp.piksi.MsgMaskSatellite; import com.swiftnav.sbp.piksi.MsgMaskSatelliteDep; -import com.swiftnav.sbp.piksi.MsgNetworkBandwidthUsage; +import com.swiftnav.sbp.piksi.MsgDeviceMonitor; +import com.swiftnav.sbp.piksi.MsgCommandReq; +import com.swiftnav.sbp.piksi.MsgCommandResp; +import com.swiftnav.sbp.piksi.MsgCommandOutput; import com.swiftnav.sbp.piksi.MsgNetworkStateReq; import com.swiftnav.sbp.piksi.MsgNetworkStateResp; -import com.swiftnav.sbp.piksi.MsgReset; -import com.swiftnav.sbp.piksi.MsgResetDep; -import com.swiftnav.sbp.piksi.MsgResetFilters; -import com.swiftnav.sbp.piksi.MsgSetTime; -import com.swiftnav.sbp.piksi.MsgSpecan; +import com.swiftnav.sbp.piksi.MsgNetworkBandwidthUsage; +import com.swiftnav.sbp.piksi.MsgCellModemStatus; import com.swiftnav.sbp.piksi.MsgSpecanDep; -import com.swiftnav.sbp.piksi.MsgThreadState; -import com.swiftnav.sbp.piksi.MsgUartState; -import com.swiftnav.sbp.piksi.MsgUartStateDepa; +import com.swiftnav.sbp.piksi.MsgSpecan; +import com.swiftnav.sbp.piksi.MsgFrontEndGain; import com.swiftnav.sbp.profiling.MsgMeasurementPoint; -import com.swiftnav.sbp.profiling.MsgProfilingResourceCounter; import com.swiftnav.sbp.profiling.MsgProfilingSystemInfo; import com.swiftnav.sbp.profiling.MsgProfilingThreadInfo; +import com.swiftnav.sbp.profiling.MsgProfilingResourceCounter; import com.swiftnav.sbp.sbas.MsgSbasRaw; -import com.swiftnav.sbp.settings.MsgSettingsReadByIndexDone; -import com.swiftnav.sbp.settings.MsgSettingsReadByIndexReq; -import com.swiftnav.sbp.settings.MsgSettingsReadByIndexResp; +import com.swiftnav.sbp.settings.MsgSettingsSave; +import com.swiftnav.sbp.settings.MsgSettingsWrite; +import com.swiftnav.sbp.settings.MsgSettingsWriteResp; import com.swiftnav.sbp.settings.MsgSettingsReadReq; import com.swiftnav.sbp.settings.MsgSettingsReadResp; +import com.swiftnav.sbp.settings.MsgSettingsReadByIndexReq; +import com.swiftnav.sbp.settings.MsgSettingsReadByIndexResp; +import com.swiftnav.sbp.settings.MsgSettingsReadByIndexDone; import com.swiftnav.sbp.settings.MsgSettingsRegister; import com.swiftnav.sbp.settings.MsgSettingsRegisterResp; -import com.swiftnav.sbp.settings.MsgSettingsSave; -import com.swiftnav.sbp.settings.MsgSettingsWrite; -import com.swiftnav.sbp.settings.MsgSettingsWriteResp; -import com.swiftnav.sbp.signing.MsgAesCmacSignature; +import com.swiftnav.sbp.signing.MsgEcdsaCertificate; import com.swiftnav.sbp.signing.MsgCertificateChain; import com.swiftnav.sbp.signing.MsgCertificateChainDep; -import com.swiftnav.sbp.signing.MsgEcdsaCertificate; +import com.swiftnav.sbp.signing.MsgAesCmacSignature; import com.swiftnav.sbp.signing.MsgEcdsaSignature; -import com.swiftnav.sbp.signing.MsgEcdsaSignatureDepA; import com.swiftnav.sbp.signing.MsgEcdsaSignatureDepB; +import com.swiftnav.sbp.signing.MsgEcdsaSignatureDepA; import com.swiftnav.sbp.signing.MsgEd25519CertificateDep; import com.swiftnav.sbp.signing.MsgEd25519SignatureDepA; import com.swiftnav.sbp.signing.MsgEd25519SignatureDepB; -import com.swiftnav.sbp.solution_meta.MsgSolnMeta; import com.swiftnav.sbp.solution_meta.MsgSolnMetaDepA; +import com.swiftnav.sbp.solution_meta.MsgSolnMeta; +import com.swiftnav.sbp.ssr.MsgSsrOrbitClock; import com.swiftnav.sbp.ssr.MsgSsrCodeBiases; -import com.swiftnav.sbp.ssr.MsgSsrCodePhaseBiasesBounds; -import com.swiftnav.sbp.ssr.MsgSsrGridDefinitionDepA; +import com.swiftnav.sbp.ssr.MsgSsrPhaseBiases; +import com.swiftnav.sbp.ssr.MsgSsrStecCorrectionDep; +import com.swiftnav.sbp.ssr.MsgSsrStecCorrection; import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrection; import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrectionBounds; -import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrectionDepA; +import com.swiftnav.sbp.ssr.MsgSsrTileDefinitionDepA; +import com.swiftnav.sbp.ssr.MsgSsrTileDefinitionDepB; +import com.swiftnav.sbp.ssr.MsgSsrTileDefinition; +import com.swiftnav.sbp.ssr.MsgSsrSatelliteApcDep; +import com.swiftnav.sbp.ssr.MsgSsrSatelliteApc; +import com.swiftnav.sbp.ssr.MsgSsrOrbitClockDepA; +import com.swiftnav.sbp.ssr.MsgSsrStecCorrectionDepA; import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrectionNoStdDepA; -import com.swiftnav.sbp.ssr.MsgSsrOrbitClock; +import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrectionDepA; +import com.swiftnav.sbp.ssr.MsgSsrGridDefinitionDepA; import com.swiftnav.sbp.ssr.MsgSsrOrbitClockBounds; +import com.swiftnav.sbp.ssr.MsgSsrCodePhaseBiasesBounds; import com.swiftnav.sbp.ssr.MsgSsrOrbitClockBoundsDegradation; -import com.swiftnav.sbp.ssr.MsgSsrOrbitClockDepA; -import com.swiftnav.sbp.ssr.MsgSsrPhaseBiases; -import com.swiftnav.sbp.ssr.MsgSsrSatelliteApc; -import com.swiftnav.sbp.ssr.MsgSsrSatelliteApcDep; -import com.swiftnav.sbp.ssr.MsgSsrStecCorrection; -import com.swiftnav.sbp.ssr.MsgSsrStecCorrectionDep; -import com.swiftnav.sbp.ssr.MsgSsrStecCorrectionDepA; -import com.swiftnav.sbp.ssr.MsgSsrTileDefinition; -import com.swiftnav.sbp.ssr.MsgSsrTileDefinitionDepA; -import com.swiftnav.sbp.ssr.MsgSsrTileDefinitionDepB; -import com.swiftnav.sbp.system.MsgCsacTelemetry; -import com.swiftnav.sbp.system.MsgCsacTelemetryLabels; +import com.swiftnav.sbp.system.MsgStartup; import com.swiftnav.sbp.system.MsgDgnssStatus; -import com.swiftnav.sbp.system.MsgGnssTimeOffset; -import com.swiftnav.sbp.system.MsgGroupMeta; import com.swiftnav.sbp.system.MsgHeartbeat; +import com.swiftnav.sbp.system.MsgStatusReport; +import com.swiftnav.sbp.system.MsgStatusJournal; import com.swiftnav.sbp.system.MsgInsStatus; +import com.swiftnav.sbp.system.MsgCsacTelemetry; +import com.swiftnav.sbp.system.MsgCsacTelemetryLabels; import com.swiftnav.sbp.system.MsgInsUpdates; +import com.swiftnav.sbp.system.MsgGnssTimeOffset; import com.swiftnav.sbp.system.MsgPpsTime; import com.swiftnav.sbp.system.MsgSensorAidEvent; -import com.swiftnav.sbp.system.MsgStartup; -import com.swiftnav.sbp.system.MsgStatusJournal; -import com.swiftnav.sbp.system.MsgStatusReport; +import com.swiftnav.sbp.system.MsgGroupMeta; import com.swiftnav.sbp.telemetry.MsgTelSv; +import com.swiftnav.sbp.tracking.MsgTrackingStateDetailedDepA; +import com.swiftnav.sbp.tracking.MsgTrackingStateDetailedDep; +import com.swiftnav.sbp.tracking.MsgTrackingState; import com.swiftnav.sbp.tracking.MsgMeasurementState; import com.swiftnav.sbp.tracking.MsgTrackingIq; -import com.swiftnav.sbp.tracking.MsgTrackingIqDepA; import com.swiftnav.sbp.tracking.MsgTrackingIqDepB; -import com.swiftnav.sbp.tracking.MsgTrackingState; +import com.swiftnav.sbp.tracking.MsgTrackingIqDepA; import com.swiftnav.sbp.tracking.MsgTrackingStateDepA; import com.swiftnav.sbp.tracking.MsgTrackingStateDepB; -import com.swiftnav.sbp.tracking.MsgTrackingStateDetailedDep; -import com.swiftnav.sbp.tracking.MsgTrackingStateDetailedDepA; import com.swiftnav.sbp.user.MsgUserData; import com.swiftnav.sbp.vehicle.MsgOdometry; import com.swiftnav.sbp.vehicle.MsgWheeltick; @@ -741,3 +743,5 @@ static SBPMessage dispatch(SBPMessage msg) throws SBPBinaryException { return msg; } } + + diff --git a/java/src/com/swiftnav/sbp/ext_events/MsgExtEvent.java b/java/src/com/swiftnav/sbp/ext_events/MsgExtEvent.java index 2b3d607e1..ecddfbf10 100644 --- a/java/src/com/swiftnav/sbp/ext_events/MsgExtEvent.java +++ b/java/src/com/swiftnav/sbp/ext_events/MsgExtEvent.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ext_events; // This file was auto-generated from yaml/swiftnav/sbp/ext_events.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_EXT_EVENT (0x0101). + +/** SBP class for message MSG_EXT_EVENT (0x0101). * - *

You can have MSG_EXT_EVENT inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_EXT_EVENT inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Reports detection of an external event, the GPS time it occurred, which pin it was and whether - * it was rising or falling. - */ + * Reports detection of an external event, the GPS time it occurred, which pin + * it was and whether it was rising or falling. */ + public class MsgExtEvent extends SBPMessage { public static final int TYPE = 0x0101; + /** GPS week number */ public int wn; - + /** GPS time of week rounded to the nearest millisecond */ public long tow; - - /** Nanosecond residual of millisecond-rounded TOW (ranges from -500000 to 500000) */ + + /** Nanosecond residual of millisecond-rounded TOW (ranges from -500000 to + * 500000) */ public int ns_residual; - + /** Flags */ public int flags; - - /** Pin number. 0..9 = DEBUG0..9. */ + + /** Pin number. 0..9 = DEBUG0..9. */ public int pin; + - public MsgExtEvent(int sender) { - super(sender, TYPE); - } - - public MsgExtEvent() { - super(TYPE); - } - - public MsgExtEvent(SBPMessage msg) throws SBPBinaryException { + public MsgExtEvent (int sender) { super(sender, TYPE); } + public MsgExtEvent () { super(TYPE); } + public MsgExtEvent (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgExtEvent, expected 257, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgExtEvent, expected 257, actual " + msg.type); } @Override @@ -67,7 +70,7 @@ protected void parse(Parser parser) throws SBPBinaryException { tow = parser.getU32(); ns_residual = parser.getS32(); flags = parser.getU8(); - pin = parser.getU8(); + pin = parser.getU8(); } @Override @@ -76,7 +79,7 @@ protected void build(Builder builder) { builder.putU32(tow); builder.putS32(ns_residual); builder.putU8(flags); - builder.putU8(pin); + builder.putU8(pin); } @Override diff --git a/java/src/com/swiftnav/sbp/file_io/MsgFileioConfigReq.java b/java/src/com/swiftnav/sbp/file_io/MsgFileioConfigReq.java index adcb6831c..a3165e7de 100644 --- a/java/src/com/swiftnav/sbp/file_io/MsgFileioConfigReq.java +++ b/java/src/com/swiftnav/sbp/file_io/MsgFileioConfigReq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.file_io; // This file was auto-generated from yaml/swiftnav/sbp/file_io.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_FILEIO_CONFIG_REQ (0x1001). +/** SBP class for message MSG_FILEIO_CONFIG_REQ (0x1001). * - *

You can have MSG_FILEIO_CONFIG_REQ inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_FILEIO_CONFIG_REQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Requests advice on the optimal configuration for a FileIO transfer. Newer version of FileIO - * can support greater throughput by supporting a large window of FileIO data that can be in-flight - * during read or write operations. - */ + * Requests advice on the optimal configuration for a FileIO transfer. Newer + * version of FileIO can support greater throughput by supporting a large + * window of FileIO data that can be in-flight during read or write + * operations. */ + public class MsgFileioConfigReq extends SBPMessage { public static final int TYPE = 0x1001; + /** Advice sequence number */ public long sequence; + - public MsgFileioConfigReq(int sender) { - super(sender, TYPE); - } - - public MsgFileioConfigReq() { - super(TYPE); - } - - public MsgFileioConfigReq(SBPMessage msg) throws SBPBinaryException { + public MsgFileioConfigReq (int sender) { super(sender, TYPE); } + public MsgFileioConfigReq () { super(TYPE); } + public MsgFileioConfigReq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFileioConfigReq, expected 4097, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFileioConfigReq, expected 4097, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - sequence = parser.getU32(); + sequence = parser.getU32(); } @Override protected void build(Builder builder) { - builder.putU32(sequence); + builder.putU32(sequence); } @Override diff --git a/java/src/com/swiftnav/sbp/file_io/MsgFileioConfigResp.java b/java/src/com/swiftnav/sbp/file_io/MsgFileioConfigResp.java index e52b6671d..926d616c6 100644 --- a/java/src/com/swiftnav/sbp/file_io/MsgFileioConfigResp.java +++ b/java/src/com/swiftnav/sbp/file_io/MsgFileioConfigResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,54 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.file_io; // This file was auto-generated from yaml/swiftnav/sbp/file_io.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_FILEIO_CONFIG_RESP (0x1002). + +/** SBP class for message MSG_FILEIO_CONFIG_RESP (0x1002). * - *

You can have MSG_FILEIO_CONFIG_RESP inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_FILEIO_CONFIG_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The advice on the optimal configuration for a FileIO transfer. Newer version of FileIO can - * support greater throughput by supporting a large window of FileIO data that can be in-flight - * during read or write operations. - */ + * The advice on the optimal configuration for a FileIO transfer. Newer + * version of FileIO can support greater throughput by supporting a large + * window of FileIO data that can be in-flight during read or write + * operations. */ + public class MsgFileioConfigResp extends SBPMessage { public static final int TYPE = 0x1002; + /** Advice sequence number */ public long sequence; - + /** The number of SBP packets in the data in-flight window */ public long window_size; - + /** The number of SBP packets sent in one PDU */ public long batch_size; - + /** The version of FileIO that is supported */ public long fileio_version; + - public MsgFileioConfigResp(int sender) { - super(sender, TYPE); - } - - public MsgFileioConfigResp() { - super(TYPE); - } - - public MsgFileioConfigResp(SBPMessage msg) throws SBPBinaryException { + public MsgFileioConfigResp (int sender) { super(sender, TYPE); } + public MsgFileioConfigResp () { super(TYPE); } + public MsgFileioConfigResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFileioConfigResp, expected 4098, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFileioConfigResp, expected 4098, actual " + msg.type); } @Override @@ -64,7 +67,7 @@ protected void parse(Parser parser) throws SBPBinaryException { sequence = parser.getU32(); window_size = parser.getU32(); batch_size = parser.getU32(); - fileio_version = parser.getU32(); + fileio_version = parser.getU32(); } @Override @@ -72,7 +75,7 @@ protected void build(Builder builder) { builder.putU32(sequence); builder.putU32(window_size); builder.putU32(batch_size); - builder.putU32(fileio_version); + builder.putU32(fileio_version); } @Override diff --git a/java/src/com/swiftnav/sbp/file_io/MsgFileioReadDirReq.java b/java/src/com/swiftnav/sbp/file_io/MsgFileioReadDirReq.java index ac3b2ede3..26d83ba02 100644 --- a/java/src/com/swiftnav/sbp/file_io/MsgFileioReadDirReq.java +++ b/java/src/com/swiftnav/sbp/file_io/MsgFileioReadDirReq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.file_io; // This file was auto-generated from yaml/swiftnav/sbp/file_io.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_FILEIO_READ_DIR_REQ (0x00A9). + +/** SBP class for message MSG_FILEIO_READ_DIR_REQ (0x00A9). * - *

You can have MSG_FILEIO_READ_DIR_REQ inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_FILEIO_READ_DIR_REQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The read directory message lists the files in a directory on the device's onboard flash file - * system. The offset parameter can be used to skip the first n elements of the file list. Returns a - * MSG_FILEIO_READ_DIR_RESP message containing the directory listings as a NULL delimited list. The - * listing is chunked over multiple SBP packets. The sequence number in the request will be returned - * in the response. If message is invalid, a followup MSG_PRINT message will print "Invalid fileio - * read message". A device will only respond to this message when it is received from sender ID - * 0x42. - */ + * The read directory message lists the files in a directory on the device's + * onboard flash file system. The offset parameter can be used to skip the + * first n elements of the file list. Returns a MSG_FILEIO_READ_DIR_RESP + * message containing the directory listings as a NULL delimited list. The + * listing is chunked over multiple SBP packets. The sequence number in the + * request will be returned in the response. If message is invalid, a + * followup MSG_PRINT message will print "Invalid fileio read message". A + * device will only respond to this message when it is received from sender ID + * 0x42. */ + public class MsgFileioReadDirReq extends SBPMessage { public static final int TYPE = 0x00A9; + /** Read sequence number */ public long sequence; - + /** The offset to skip the first n elements of the file list */ public long offset; - + /** Name of the directory to list */ public String dirname; + - public MsgFileioReadDirReq(int sender) { - super(sender, TYPE); - } - - public MsgFileioReadDirReq() { - super(TYPE); - } - - public MsgFileioReadDirReq(SBPMessage msg) throws SBPBinaryException { + public MsgFileioReadDirReq (int sender) { super(sender, TYPE); } + public MsgFileioReadDirReq () { super(TYPE); } + public MsgFileioReadDirReq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFileioReadDirReq, expected 169, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFileioReadDirReq, expected 169, actual " + msg.type); } @Override @@ -64,14 +68,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ sequence = parser.getU32(); offset = parser.getU32(); - dirname = parser.getString(); + dirname = parser.getString(); } @Override protected void build(Builder builder) { builder.putU32(sequence); builder.putU32(offset); - builder.putString(dirname); + builder.putString(dirname); } @Override diff --git a/java/src/com/swiftnav/sbp/file_io/MsgFileioReadDirResp.java b/java/src/com/swiftnav/sbp/file_io/MsgFileioReadDirResp.java index 46cdcf8df..e582a0b07 100644 --- a/java/src/com/swiftnav/sbp/file_io/MsgFileioReadDirResp.java +++ b/java/src/com/swiftnav/sbp/file_io/MsgFileioReadDirResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,62 +9,64 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.file_io; // This file was auto-generated from yaml/swiftnav/sbp/file_io.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_FILEIO_READ_DIR_RESP (0x00AA). +/** SBP class for message MSG_FILEIO_READ_DIR_RESP (0x00AA). * - *

You can have MSG_FILEIO_READ_DIR_RESP inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_FILEIO_READ_DIR_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The read directory message lists the files in a directory on the device's onboard flash file - * system. Message contains the directory listings as a NULL delimited list. The listing is chunked - * over multiple SBP packets and the end of the list is identified by an packet with no entries. The - * sequence number in the response is preserved from the request. - */ + * The read directory message lists the files in a directory on the device's + * onboard flash file system. Message contains the directory listings as a + * NULL delimited list. The listing is chunked over multiple SBP packets and + * the end of the list is identified by an packet with no entries. The + * sequence number in the response is preserved from the request. */ + public class MsgFileioReadDirResp extends SBPMessage { public static final int TYPE = 0x00AA; + /** Read sequence number */ public long sequence; - + /** Contents of read directory */ public String contents; + - public MsgFileioReadDirResp(int sender) { - super(sender, TYPE); - } - - public MsgFileioReadDirResp() { - super(TYPE); - } - - public MsgFileioReadDirResp(SBPMessage msg) throws SBPBinaryException { + public MsgFileioReadDirResp (int sender) { super(sender, TYPE); } + public MsgFileioReadDirResp () { super(TYPE); } + public MsgFileioReadDirResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFileioReadDirResp, expected 170, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFileioReadDirResp, expected 170, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ sequence = parser.getU32(); - contents = parser.getString(); + contents = parser.getString(); } @Override protected void build(Builder builder) { builder.putU32(sequence); - builder.putString(contents); + builder.putString(contents); } @Override diff --git a/java/src/com/swiftnav/sbp/file_io/MsgFileioReadReq.java b/java/src/com/swiftnav/sbp/file_io/MsgFileioReadReq.java index 855067435..55fa748ec 100644 --- a/java/src/com/swiftnav/sbp/file_io/MsgFileioReadReq.java +++ b/java/src/com/swiftnav/sbp/file_io/MsgFileioReadReq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,59 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.file_io; // This file was auto-generated from yaml/swiftnav/sbp/file_io.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_FILEIO_READ_REQ (0x00A8). + +/** SBP class for message MSG_FILEIO_READ_REQ (0x00A8). * - *

You can have MSG_FILEIO_READ_REQ inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_FILEIO_READ_REQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The file read message reads a certain length (up to 255 bytes) from a given offset into a - * file, and returns the data in a MSG_FILEIO_READ_RESP message where the message length field - * indicates how many bytes were successfully read. The sequence number in the request will be - * returned in the response. If the message is invalid, a followup MSG_PRINT message will print - * "Invalid fileio read message". A device will only respond to this message when it is received - * from sender ID 0x42. - */ + * The file read message reads a certain length (up to 255 bytes) from a given + * offset into a file, and returns the data in a MSG_FILEIO_READ_RESP message + * where the message length field indicates how many bytes were successfully + * read. The sequence number in the request will be returned in the response. + * If the message is invalid, a followup MSG_PRINT message will print "Invalid + * fileio read message". A device will only respond to this message when it is + * received from sender ID 0x42. */ + public class MsgFileioReadReq extends SBPMessage { public static final int TYPE = 0x00A8; + /** Read sequence number */ public long sequence; - + /** File offset */ public long offset; - + /** Chunk size to read */ public int chunk_size; - + /** Name of the file to read from */ public String filename; + - public MsgFileioReadReq(int sender) { - super(sender, TYPE); - } - - public MsgFileioReadReq() { - super(TYPE); - } - - public MsgFileioReadReq(SBPMessage msg) throws SBPBinaryException { + public MsgFileioReadReq (int sender) { super(sender, TYPE); } + public MsgFileioReadReq () { super(TYPE); } + public MsgFileioReadReq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFileioReadReq, expected 168, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFileioReadReq, expected 168, actual " + msg.type); } @Override @@ -67,7 +70,7 @@ protected void parse(Parser parser) throws SBPBinaryException { sequence = parser.getU32(); offset = parser.getU32(); chunk_size = parser.getU8(); - filename = parser.getString(); + filename = parser.getString(); } @Override @@ -75,7 +78,7 @@ protected void build(Builder builder) { builder.putU32(sequence); builder.putU32(offset); builder.putU8(chunk_size); - builder.putString(filename); + builder.putString(filename); } @Override diff --git a/java/src/com/swiftnav/sbp/file_io/MsgFileioReadResp.java b/java/src/com/swiftnav/sbp/file_io/MsgFileioReadResp.java index b5af5db30..92fd66199 100644 --- a/java/src/com/swiftnav/sbp/file_io/MsgFileioReadResp.java +++ b/java/src/com/swiftnav/sbp/file_io/MsgFileioReadResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,62 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.file_io; // This file was auto-generated from yaml/swiftnav/sbp/file_io.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_FILEIO_READ_RESP (0x00A3). +/** SBP class for message MSG_FILEIO_READ_RESP (0x00A3). * - *

You can have MSG_FILEIO_READ_RESP inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_FILEIO_READ_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The file read message reads a certain length (up to 255 bytes) from a given offset into a - * file, and returns the data in a message where the message length field indicates how many bytes - * were successfully read. The sequence number in the response is preserved from the request. - */ + * The file read message reads a certain length (up to 255 bytes) from a given + * offset into a file, and returns the data in a message where the message + * length field indicates how many bytes were successfully read. The sequence + * number in the response is preserved from the request. */ + public class MsgFileioReadResp extends SBPMessage { public static final int TYPE = 0x00A3; + /** Read sequence number */ public long sequence; - + /** Contents of read file */ public int[] contents; + - public MsgFileioReadResp(int sender) { - super(sender, TYPE); - } - - public MsgFileioReadResp() { - super(TYPE); - } - - public MsgFileioReadResp(SBPMessage msg) throws SBPBinaryException { + public MsgFileioReadResp (int sender) { super(sender, TYPE); } + public MsgFileioReadResp () { super(TYPE); } + public MsgFileioReadResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFileioReadResp, expected 163, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFileioReadResp, expected 163, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ sequence = parser.getU32(); - contents = parser.getArrayofU8(); + contents = parser.getArrayofU8(); } @Override protected void build(Builder builder) { builder.putU32(sequence); - builder.putArrayofU8(contents); + builder.putArrayofU8(contents); } @Override diff --git a/java/src/com/swiftnav/sbp/file_io/MsgFileioRemove.java b/java/src/com/swiftnav/sbp/file_io/MsgFileioRemove.java index 151abe48b..88f43b7a4 100644 --- a/java/src/com/swiftnav/sbp/file_io/MsgFileioRemove.java +++ b/java/src/com/swiftnav/sbp/file_io/MsgFileioRemove.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.file_io; // This file was auto-generated from yaml/swiftnav/sbp/file_io.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_FILEIO_REMOVE (0x00AC). +/** SBP class for message MSG_FILEIO_REMOVE (0x00AC). * - *

You can have MSG_FILEIO_REMOVE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_FILEIO_REMOVE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The file remove message deletes a file from the file system. If the message is invalid, a - * followup MSG_PRINT message will print "Invalid fileio remove message". A device will only process - * this message when it is received from sender ID 0x42. - */ + * The file remove message deletes a file from the file system. If the message + * is invalid, a followup MSG_PRINT message will print "Invalid fileio remove + * message". A device will only process this message when it is received from + * sender ID 0x42. */ + public class MsgFileioRemove extends SBPMessage { public static final int TYPE = 0x00AC; + /** Name of the file to delete */ public String filename; + - public MsgFileioRemove(int sender) { - super(sender, TYPE); - } - - public MsgFileioRemove() { - super(TYPE); - } - - public MsgFileioRemove(SBPMessage msg) throws SBPBinaryException { + public MsgFileioRemove (int sender) { super(sender, TYPE); } + public MsgFileioRemove () { super(TYPE); } + public MsgFileioRemove (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFileioRemove, expected 172, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFileioRemove, expected 172, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - filename = parser.getString(); + filename = parser.getString(); } @Override protected void build(Builder builder) { - builder.putString(filename); + builder.putString(filename); } @Override diff --git a/java/src/com/swiftnav/sbp/file_io/MsgFileioWriteReq.java b/java/src/com/swiftnav/sbp/file_io/MsgFileioWriteReq.java index 6555886ef..44a14e0ec 100644 --- a/java/src/com/swiftnav/sbp/file_io/MsgFileioWriteReq.java +++ b/java/src/com/swiftnav/sbp/file_io/MsgFileioWriteReq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,59 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.file_io; // This file was auto-generated from yaml/swiftnav/sbp/file_io.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_FILEIO_WRITE_REQ (0x00AD). + +/** SBP class for message MSG_FILEIO_WRITE_REQ (0x00AD). * - *

You can have MSG_FILEIO_WRITE_REQ inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_FILEIO_WRITE_REQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The file write message writes a certain length (up to 255 bytes) of data to a file at a given - * offset. Returns a copy of the original MSG_FILEIO_WRITE_RESP message to check integrity of the - * write. The sequence number in the request will be returned in the response. If message is - * invalid, a followup MSG_PRINT message will print "Invalid fileio write message". A device will - * only process this message when it is received from sender ID 0x42. - */ + * The file write message writes a certain length (up to 255 bytes) of data to + * a file at a given offset. Returns a copy of the original + * MSG_FILEIO_WRITE_RESP message to check integrity of the write. The sequence + * number in the request will be returned in the response. If message is + * invalid, a followup MSG_PRINT message will print "Invalid fileio write + * message". A device will only process this message when it is received from + * sender ID 0x42. */ + public class MsgFileioWriteReq extends SBPMessage { public static final int TYPE = 0x00AD; + /** Write sequence number */ public long sequence; - + /** Offset into the file at which to start writing in bytes */ public long offset; - + /** Name of the file to write to */ public String filename; - + /** Variable-length array of data to write */ public int[] data; + - public MsgFileioWriteReq(int sender) { - super(sender, TYPE); - } - - public MsgFileioWriteReq() { - super(TYPE); - } - - public MsgFileioWriteReq(SBPMessage msg) throws SBPBinaryException { + public MsgFileioWriteReq (int sender) { super(sender, TYPE); } + public MsgFileioWriteReq () { super(TYPE); } + public MsgFileioWriteReq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFileioWriteReq, expected 173, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFileioWriteReq, expected 173, actual " + msg.type); } @Override @@ -67,7 +70,7 @@ protected void parse(Parser parser) throws SBPBinaryException { sequence = parser.getU32(); offset = parser.getU32(); filename = parser.getString(); - data = parser.getArrayofU8(); + data = parser.getArrayofU8(); } @Override @@ -75,7 +78,7 @@ protected void build(Builder builder) { builder.putU32(sequence); builder.putU32(offset); builder.putString(filename); - builder.putArrayofU8(data); + builder.putArrayofU8(data); } @Override diff --git a/java/src/com/swiftnav/sbp/file_io/MsgFileioWriteResp.java b/java/src/com/swiftnav/sbp/file_io/MsgFileioWriteResp.java index c3356af5f..ce4dfa98a 100644 --- a/java/src/com/swiftnav/sbp/file_io/MsgFileioWriteResp.java +++ b/java/src/com/swiftnav/sbp/file_io/MsgFileioWriteResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.file_io; // This file was auto-generated from yaml/swiftnav/sbp/file_io.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_FILEIO_WRITE_RESP (0x00AB). +/** SBP class for message MSG_FILEIO_WRITE_RESP (0x00AB). * - *

You can have MSG_FILEIO_WRITE_RESP inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_FILEIO_WRITE_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The file write message writes a certain length (up to 255 bytes) of data to a file at a given - * offset. The message is a copy of the original MSG_FILEIO_WRITE_REQ message to check integrity of - * the write. The sequence number in the response is preserved from the request. - */ + * The file write message writes a certain length (up to 255 bytes) of data to + * a file at a given offset. The message is a copy of the original + * MSG_FILEIO_WRITE_REQ message to check integrity of the write. The sequence + * number in the response is preserved from the request. */ + public class MsgFileioWriteResp extends SBPMessage { public static final int TYPE = 0x00AB; + /** Write sequence number */ public long sequence; + - public MsgFileioWriteResp(int sender) { - super(sender, TYPE); - } - - public MsgFileioWriteResp() { - super(TYPE); - } - - public MsgFileioWriteResp(SBPMessage msg) throws SBPBinaryException { + public MsgFileioWriteResp (int sender) { super(sender, TYPE); } + public MsgFileioWriteResp () { super(TYPE); } + public MsgFileioWriteResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFileioWriteResp, expected 171, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFileioWriteResp, expected 171, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - sequence = parser.getU32(); + sequence = parser.getU32(); } @Override protected void build(Builder builder) { - builder.putU32(sequence); + builder.putU32(sequence); } @Override diff --git a/java/src/com/swiftnav/sbp/flash/MsgFlashDone.java b/java/src/com/swiftnav/sbp/flash/MsgFlashDone.java index cf2b9bfa8..fd3eb3451 100644 --- a/java/src/com/swiftnav/sbp/flash/MsgFlashDone.java +++ b/java/src/com/swiftnav/sbp/flash/MsgFlashDone.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.flash; // This file was auto-generated from yaml/swiftnav/sbp/flash.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_FLASH_DONE (0x00E0). +/** SBP class for message MSG_FLASH_DONE (0x00E0). * - *

You can have MSG_FLASH_DONE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_FLASH_DONE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message defines success or failure codes for a variety of flash memory requests from the - * host to the device. Flash read and write messages, such as MSG_FLASH_READ_REQ, or - * MSG_FLASH_PROGRAM, may return this message on failure. - */ + * This message defines success or failure codes for a variety of flash memory + * requests from the host to the device. Flash read and write messages, such + * as MSG_FLASH_READ_REQ, or MSG_FLASH_PROGRAM, may return this message on + * failure. */ + public class MsgFlashDone extends SBPMessage { public static final int TYPE = 0x00E0; + /** Response flags */ public int response; + - public MsgFlashDone(int sender) { - super(sender, TYPE); - } - - public MsgFlashDone() { - super(TYPE); - } - - public MsgFlashDone(SBPMessage msg) throws SBPBinaryException { + public MsgFlashDone (int sender) { super(sender, TYPE); } + public MsgFlashDone () { super(TYPE); } + public MsgFlashDone (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFlashDone, expected 224, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFlashDone, expected 224, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - response = parser.getU8(); + response = parser.getU8(); } @Override protected void build(Builder builder) { - builder.putU8(response); + builder.putU8(response); } @Override diff --git a/java/src/com/swiftnav/sbp/flash/MsgFlashErase.java b/java/src/com/swiftnav/sbp/flash/MsgFlashErase.java index a7a3a3da4..19d36ccff 100644 --- a/java/src/com/swiftnav/sbp/flash/MsgFlashErase.java +++ b/java/src/com/swiftnav/sbp/flash/MsgFlashErase.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.flash; // This file was auto-generated from yaml/swiftnav/sbp/flash.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_FLASH_ERASE (0x00E2). +/** SBP class for message MSG_FLASH_ERASE (0x00E2). * - *

You can have MSG_FLASH_ERASE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_FLASH_ERASE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The flash erase message from the host erases a sector of either the STM or M25 onboard flash - * memory. The device will reply with a MSG_FLASH_DONE message containing the return code - FLASH_OK - * (0) on success or FLASH_INVALID_FLASH (1) if the flash specified is invalid. - */ + * The flash erase message from the host erases a sector of either the STM or + * M25 onboard flash memory. The device will reply with a MSG_FLASH_DONE + * message containing the return code - FLASH_OK (0) on success or + * FLASH_INVALID_FLASH (1) if the flash specified is invalid. */ + public class MsgFlashErase extends SBPMessage { public static final int TYPE = 0x00E2; + /** Target flags */ public int target; - + /** Flash sector number to erase (0-11 for the STM, 0-15 for the M25) */ public long sector_num; + - public MsgFlashErase(int sender) { - super(sender, TYPE); - } - - public MsgFlashErase() { - super(TYPE); - } - - public MsgFlashErase(SBPMessage msg) throws SBPBinaryException { + public MsgFlashErase (int sender) { super(sender, TYPE); } + public MsgFlashErase () { super(TYPE); } + public MsgFlashErase (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFlashErase, expected 226, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFlashErase, expected 226, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ target = parser.getU8(); - sector_num = parser.getU32(); + sector_num = parser.getU32(); } @Override protected void build(Builder builder) { builder.putU8(target); - builder.putU32(sector_num); + builder.putU32(sector_num); } @Override diff --git a/java/src/com/swiftnav/sbp/flash/MsgFlashProgram.java b/java/src/com/swiftnav/sbp/flash/MsgFlashProgram.java index 9b11564e1..0eb3d297f 100644 --- a/java/src/com/swiftnav/sbp/flash/MsgFlashProgram.java +++ b/java/src/com/swiftnav/sbp/flash/MsgFlashProgram.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.flash; // This file was auto-generated from yaml/swiftnav/sbp/flash.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_FLASH_PROGRAM (0x00E6). + +/** SBP class for message MSG_FLASH_PROGRAM (0x00E6). * - *

You can have MSG_FLASH_PROGRAM inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_FLASH_PROGRAM inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The flash program message programs a set of addresses of either the STM or M25 flash. The - * device replies with either a MSG_FLASH_DONE message containing the return code FLASH_OK (0) on - * success, or FLASH_INVALID_LEN (2) if the maximum write size is exceeded. Note that the - * sector-containing addresses must be erased before addresses can be programmed. - */ + * The flash program message programs a set of addresses of either the STM or + * M25 flash. The device replies with either a MSG_FLASH_DONE message + * containing the return code FLASH_OK (0) on success, or FLASH_INVALID_LEN + * (2) if the maximum write size is exceeded. Note that the sector-containing + * addresses must be erased before addresses can be programmed. */ + public class MsgFlashProgram extends SBPMessage { public static final int TYPE = 0x00E6; + /** Target flags */ public int target; - + /** Starting address offset to program */ public int[] addr_start; - - /** Length of set of addresses to program, counting up from starting address */ + + /** Length of set of addresses to program, counting up from starting + * address */ public int addr_len; - + /** Data to program addresses with, with length N=addr_len */ public int[] data; + - public MsgFlashProgram(int sender) { - super(sender, TYPE); - } - - public MsgFlashProgram() { - super(TYPE); - } - - public MsgFlashProgram(SBPMessage msg) throws SBPBinaryException { + public MsgFlashProgram (int sender) { super(sender, TYPE); } + public MsgFlashProgram () { super(TYPE); } + public MsgFlashProgram (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFlashProgram, expected 230, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFlashProgram, expected 230, actual " + msg.type); } @Override @@ -66,7 +69,7 @@ protected void parse(Parser parser) throws SBPBinaryException { target = parser.getU8(); addr_start = parser.getArrayofU8(3); addr_len = parser.getU8(); - data = parser.getArrayofU8(); + data = parser.getArrayofU8(); } @Override @@ -74,7 +77,7 @@ protected void build(Builder builder) { builder.putU8(target); builder.putArrayofU8(addr_start, 3); builder.putU8(addr_len); - builder.putArrayofU8(data); + builder.putArrayofU8(data); } @Override diff --git a/java/src/com/swiftnav/sbp/flash/MsgFlashReadReq.java b/java/src/com/swiftnav/sbp/flash/MsgFlashReadReq.java index 30f75d94b..49b7e4aba 100644 --- a/java/src/com/swiftnav/sbp/flash/MsgFlashReadReq.java +++ b/java/src/com/swiftnav/sbp/flash/MsgFlashReadReq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,53 +9,55 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.flash; // This file was auto-generated from yaml/swiftnav/sbp/flash.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_FLASH_READ_REQ (0x00E7). + +/** SBP class for message MSG_FLASH_READ_REQ (0x00E7). * - *

You can have MSG_FLASH_READ_REQ inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_FLASH_READ_REQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The flash read message reads a set of addresses of either the STM or M25 onboard flash. The - * device replies with a MSG_FLASH_READ_RESP message containing either the read data on success or a - * MSG_FLASH_DONE message containing the return code FLASH_INVALID_LEN (2) if the maximum read size - * is exceeded or FLASH_INVALID_ADDR (3) if the address is outside of the allowed range. - */ + * The flash read message reads a set of addresses of either the STM or M25 + * onboard flash. The device replies with a MSG_FLASH_READ_RESP message + * containing either the read data on success or a MSG_FLASH_DONE message + * containing the return code FLASH_INVALID_LEN (2) if the maximum read size + * is exceeded or FLASH_INVALID_ADDR (3) if the address is outside of the + * allowed range. */ + public class MsgFlashReadReq extends SBPMessage { public static final int TYPE = 0x00E7; + /** Target flags */ public int target; - + /** Starting address offset to read from */ public int[] addr_start; - + /** Length of set of addresses to read, counting up from starting address */ public int addr_len; + - public MsgFlashReadReq(int sender) { - super(sender, TYPE); - } - - public MsgFlashReadReq() { - super(TYPE); - } - - public MsgFlashReadReq(SBPMessage msg) throws SBPBinaryException { + public MsgFlashReadReq (int sender) { super(sender, TYPE); } + public MsgFlashReadReq () { super(TYPE); } + public MsgFlashReadReq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFlashReadReq, expected 231, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFlashReadReq, expected 231, actual " + msg.type); } @Override @@ -62,14 +65,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ target = parser.getU8(); addr_start = parser.getArrayofU8(3); - addr_len = parser.getU8(); + addr_len = parser.getU8(); } @Override protected void build(Builder builder) { builder.putU8(target); builder.putArrayofU8(addr_start, 3); - builder.putU8(addr_len); + builder.putU8(addr_len); } @Override diff --git a/java/src/com/swiftnav/sbp/flash/MsgFlashReadResp.java b/java/src/com/swiftnav/sbp/flash/MsgFlashReadResp.java index dfc42d386..dc2aefe39 100644 --- a/java/src/com/swiftnav/sbp/flash/MsgFlashReadResp.java +++ b/java/src/com/swiftnav/sbp/flash/MsgFlashReadResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,53 +9,55 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.flash; // This file was auto-generated from yaml/swiftnav/sbp/flash.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_FLASH_READ_RESP (0x00E1). + +/** SBP class for message MSG_FLASH_READ_RESP (0x00E1). * - *

You can have MSG_FLASH_READ_RESP inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_FLASH_READ_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The flash read message reads a set of addresses of either the STM or M25 onboard flash. The - * device replies with a MSG_FLASH_READ_RESP message containing either the read data on success or a - * MSG_FLASH_DONE message containing the return code FLASH_INVALID_LEN (2) if the maximum read size - * is exceeded or FLASH_INVALID_ADDR (3) if the address is outside of the allowed range. - */ + * The flash read message reads a set of addresses of either the STM or M25 + * onboard flash. The device replies with a MSG_FLASH_READ_RESP message + * containing either the read data on success or a MSG_FLASH_DONE message + * containing the return code FLASH_INVALID_LEN (2) if the maximum read size + * is exceeded or FLASH_INVALID_ADDR (3) if the address is outside of the + * allowed range. */ + public class MsgFlashReadResp extends SBPMessage { public static final int TYPE = 0x00E1; + /** Target flags */ public int target; - + /** Starting address offset to read from */ public int[] addr_start; - + /** Length of set of addresses to read, counting up from starting address */ public int addr_len; + - public MsgFlashReadResp(int sender) { - super(sender, TYPE); - } - - public MsgFlashReadResp() { - super(TYPE); - } - - public MsgFlashReadResp(SBPMessage msg) throws SBPBinaryException { + public MsgFlashReadResp (int sender) { super(sender, TYPE); } + public MsgFlashReadResp () { super(TYPE); } + public MsgFlashReadResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFlashReadResp, expected 225, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFlashReadResp, expected 225, actual " + msg.type); } @Override @@ -62,14 +65,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ target = parser.getU8(); addr_start = parser.getArrayofU8(3); - addr_len = parser.getU8(); + addr_len = parser.getU8(); } @Override protected void build(Builder builder) { builder.putU8(target); builder.putArrayofU8(addr_start, 3); - builder.putU8(addr_len); + builder.putU8(addr_len); } @Override diff --git a/java/src/com/swiftnav/sbp/flash/MsgM25FlashWriteStatus.java b/java/src/com/swiftnav/sbp/flash/MsgM25FlashWriteStatus.java index 9a2ef2bb9..0c0ac2763 100644 --- a/java/src/com/swiftnav/sbp/flash/MsgM25FlashWriteStatus.java +++ b/java/src/com/swiftnav/sbp/flash/MsgM25FlashWriteStatus.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.flash; // This file was auto-generated from yaml/swiftnav/sbp/flash.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_M25_FLASH_WRITE_STATUS (0x00F3). +/** SBP class for message MSG_M25_FLASH_WRITE_STATUS (0x00F3). * - *

You can have MSG_M25_FLASH_WRITE_STATUS inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_M25_FLASH_WRITE_STATUS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The flash status message writes to the 8-bit M25 flash status register. The device replies - * with a MSG_FLASH_DONE message. - */ + * The flash status message writes to the 8-bit M25 flash status register. The + * device replies with a MSG_FLASH_DONE message. */ + public class MsgM25FlashWriteStatus extends SBPMessage { public static final int TYPE = 0x00F3; + /** Byte to write to the M25 flash status register */ public int[] status; + - public MsgM25FlashWriteStatus(int sender) { - super(sender, TYPE); - } - - public MsgM25FlashWriteStatus() { - super(TYPE); - } - - public MsgM25FlashWriteStatus(SBPMessage msg) throws SBPBinaryException { + public MsgM25FlashWriteStatus (int sender) { super(sender, TYPE); } + public MsgM25FlashWriteStatus () { super(TYPE); } + public MsgM25FlashWriteStatus (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgM25FlashWriteStatus, expected 243, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgM25FlashWriteStatus, expected 243, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - status = parser.getArrayofU8(1); + status = parser.getArrayofU8(1); } @Override protected void build(Builder builder) { - builder.putArrayofU8(status, 1); + builder.putArrayofU8(status, 1); } @Override diff --git a/java/src/com/swiftnav/sbp/flash/MsgStmFlashLockSector.java b/java/src/com/swiftnav/sbp/flash/MsgStmFlashLockSector.java index 3530b9462..95af9ba51 100644 --- a/java/src/com/swiftnav/sbp/flash/MsgStmFlashLockSector.java +++ b/java/src/com/swiftnav/sbp/flash/MsgStmFlashLockSector.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.flash; // This file was auto-generated from yaml/swiftnav/sbp/flash.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_STM_FLASH_LOCK_SECTOR (0x00E3). +/** SBP class for message MSG_STM_FLASH_LOCK_SECTOR (0x00E3). * - *

You can have MSG_STM_FLASH_LOCK_SECTOR inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_STM_FLASH_LOCK_SECTOR inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The flash lock message locks a sector of the STM flash memory. The device replies with a - * MSG_FLASH_DONE message. - */ + * The flash lock message locks a sector of the STM flash memory. The device + * replies with a MSG_FLASH_DONE message. */ + public class MsgStmFlashLockSector extends SBPMessage { public static final int TYPE = 0x00E3; + /** Flash sector number to lock */ public long sector; + - public MsgStmFlashLockSector(int sender) { - super(sender, TYPE); - } - - public MsgStmFlashLockSector() { - super(TYPE); - } - - public MsgStmFlashLockSector(SBPMessage msg) throws SBPBinaryException { + public MsgStmFlashLockSector (int sender) { super(sender, TYPE); } + public MsgStmFlashLockSector () { super(TYPE); } + public MsgStmFlashLockSector (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgStmFlashLockSector, expected 227, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgStmFlashLockSector, expected 227, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - sector = parser.getU32(); + sector = parser.getU32(); } @Override protected void build(Builder builder) { - builder.putU32(sector); + builder.putU32(sector); } @Override diff --git a/java/src/com/swiftnav/sbp/flash/MsgStmFlashUnlockSector.java b/java/src/com/swiftnav/sbp/flash/MsgStmFlashUnlockSector.java index 13e5156f6..f25b353af 100644 --- a/java/src/com/swiftnav/sbp/flash/MsgStmFlashUnlockSector.java +++ b/java/src/com/swiftnav/sbp/flash/MsgStmFlashUnlockSector.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.flash; // This file was auto-generated from yaml/swiftnav/sbp/flash.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_STM_FLASH_UNLOCK_SECTOR (0x00E4). +/** SBP class for message MSG_STM_FLASH_UNLOCK_SECTOR (0x00E4). * - *

You can have MSG_STM_FLASH_UNLOCK_SECTOR inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_STM_FLASH_UNLOCK_SECTOR inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The flash unlock message unlocks a sector of the STM flash memory. The device replies with a - * MSG_FLASH_DONE message. - */ + * The flash unlock message unlocks a sector of the STM flash memory. The + * device replies with a MSG_FLASH_DONE message. */ + public class MsgStmFlashUnlockSector extends SBPMessage { public static final int TYPE = 0x00E4; + /** Flash sector number to unlock */ public long sector; + - public MsgStmFlashUnlockSector(int sender) { - super(sender, TYPE); - } - - public MsgStmFlashUnlockSector() { - super(TYPE); - } - - public MsgStmFlashUnlockSector(SBPMessage msg) throws SBPBinaryException { + public MsgStmFlashUnlockSector (int sender) { super(sender, TYPE); } + public MsgStmFlashUnlockSector () { super(TYPE); } + public MsgStmFlashUnlockSector (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgStmFlashUnlockSector, expected 228, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgStmFlashUnlockSector, expected 228, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - sector = parser.getU32(); + sector = parser.getU32(); } @Override protected void build(Builder builder) { - builder.putU32(sector); + builder.putU32(sector); } @Override diff --git a/java/src/com/swiftnav/sbp/flash/MsgStmUniqueIdReq.java b/java/src/com/swiftnav/sbp/flash/MsgStmUniqueIdReq.java index 9de61b55e..7b40798c6 100644 --- a/java/src/com/swiftnav/sbp/flash/MsgStmUniqueIdReq.java +++ b/java/src/com/swiftnav/sbp/flash/MsgStmUniqueIdReq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,42 +9,43 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.flash; // This file was auto-generated from yaml/swiftnav/sbp/flash.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_STM_UNIQUE_ID_REQ (0x00E8). +/** SBP class for message MSG_STM_UNIQUE_ID_REQ (0x00E8). * - *

You can have MSG_STM_UNIQUE_ID_REQ inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_STM_UNIQUE_ID_REQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reads the device's hard-coded unique ID. The host requests the ID by sending a - * MSG_STM_UNIQUE_ID_REQ. The device responds with a MSG_STM_UNIQUE_ID_RESP with the 12-byte unique - * ID in the payload. - */ + * This message reads the device's hard-coded unique ID. The host requests the + * ID by sending a MSG_STM_UNIQUE_ID_REQ. The device responds with a + * MSG_STM_UNIQUE_ID_RESP with the 12-byte unique ID in the payload. */ + public class MsgStmUniqueIdReq extends SBPMessage { public static final int TYPE = 0x00E8; - public MsgStmUniqueIdReq(int sender) { - super(sender, TYPE); - } - - public MsgStmUniqueIdReq() { - super(TYPE); - } + - public MsgStmUniqueIdReq(SBPMessage msg) throws SBPBinaryException { + public MsgStmUniqueIdReq (int sender) { super(sender, TYPE); } + public MsgStmUniqueIdReq () { super(TYPE); } + public MsgStmUniqueIdReq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgStmUniqueIdReq, expected 232, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgStmUniqueIdReq, expected 232, actual " + msg.type); } @Override diff --git a/java/src/com/swiftnav/sbp/flash/MsgStmUniqueIdResp.java b/java/src/com/swiftnav/sbp/flash/MsgStmUniqueIdResp.java index b26b11f2e..79b2028a8 100644 --- a/java/src/com/swiftnav/sbp/flash/MsgStmUniqueIdResp.java +++ b/java/src/com/swiftnav/sbp/flash/MsgStmUniqueIdResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,57 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.flash; // This file was auto-generated from yaml/swiftnav/sbp/flash.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_STM_UNIQUE_ID_RESP (0x00E5). +/** SBP class for message MSG_STM_UNIQUE_ID_RESP (0x00E5). * - *

You can have MSG_STM_UNIQUE_ID_RESP inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_STM_UNIQUE_ID_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reads the device's hard-coded unique ID. The host requests the ID by sending a - * MSG_STM_UNIQUE_ID_REQ. The device responds with a MSG_STM_UNIQUE_ID_RESP with the 12-byte unique - * ID in the payload. - */ + * This message reads the device's hard-coded unique ID. The host requests the + * ID by sending a MSG_STM_UNIQUE_ID_REQ. The device responds with a + * MSG_STM_UNIQUE_ID_RESP with the 12-byte unique ID in the payload. */ + public class MsgStmUniqueIdResp extends SBPMessage { public static final int TYPE = 0x00E5; + /** Device unique ID */ public int[] stm_id; + - public MsgStmUniqueIdResp(int sender) { - super(sender, TYPE); - } - - public MsgStmUniqueIdResp() { - super(TYPE); - } - - public MsgStmUniqueIdResp(SBPMessage msg) throws SBPBinaryException { + public MsgStmUniqueIdResp (int sender) { super(sender, TYPE); } + public MsgStmUniqueIdResp () { super(TYPE); } + public MsgStmUniqueIdResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgStmUniqueIdResp, expected 229, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgStmUniqueIdResp, expected 229, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - stm_id = parser.getArrayofU8(12); + stm_id = parser.getArrayofU8(12); } @Override protected void build(Builder builder) { - builder.putArrayofU8(stm_id, 12); + builder.putArrayofU8(stm_id, 12); } @Override diff --git a/java/src/com/swiftnav/sbp/gnss/CarrierPhase.java b/java/src/com/swiftnav/sbp/gnss/CarrierPhase.java index 29d1e2e9c..7d3a391d5 100644 --- a/java/src/com/swiftnav/sbp/gnss/CarrierPhase.java +++ b/java/src/com/swiftnav/sbp/gnss/CarrierPhase.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,26 +9,31 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.gnss; // This file was auto-generated from yaml/swiftnav/sbp/gnss.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class CarrierPhase extends SBPStruct { - + /** Carrier phase whole cycles */ public int i; - + /** Carrier phase fractional part */ public int f; + - public CarrierPhase() {} + public CarrierPhase () {} @Override public CarrierPhase parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/gnss/GPSTime.java b/java/src/com/swiftnav/sbp/gnss/GPSTime.java index bda6c7d39..8e4a82154 100644 --- a/java/src/com/swiftnav/sbp/gnss/GPSTime.java +++ b/java/src/com/swiftnav/sbp/gnss/GPSTime.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,29 +9,34 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.gnss; // This file was auto-generated from yaml/swiftnav/sbp/gnss.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class GPSTime extends SBPStruct { - + /** Milliseconds since start of GPS week */ public long tow; - + /** Nanosecond residual of millisecond-rounded TOW (ranges from -500000 to 500000) */ public int ns_residual; - + /** GPS week number */ public int wn; + - public GPSTime() {} + public GPSTime () {} @Override public GPSTime parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/gnss/GPSTimeDep.java b/java/src/com/swiftnav/sbp/gnss/GPSTimeDep.java index 645053546..84cc2bea5 100644 --- a/java/src/com/swiftnav/sbp/gnss/GPSTimeDep.java +++ b/java/src/com/swiftnav/sbp/gnss/GPSTimeDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,26 +9,31 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.gnss; // This file was auto-generated from yaml/swiftnav/sbp/gnss.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class GPSTimeDep extends SBPStruct { - + /** Milliseconds since start of GPS week */ public long tow; - + /** GPS week number */ public int wn; + - public GPSTimeDep() {} + public GPSTimeDep () {} @Override public GPSTimeDep parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/gnss/GPSTimeSec.java b/java/src/com/swiftnav/sbp/gnss/GPSTimeSec.java index bb44e7633..d83de4925 100644 --- a/java/src/com/swiftnav/sbp/gnss/GPSTimeSec.java +++ b/java/src/com/swiftnav/sbp/gnss/GPSTimeSec.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,26 +9,31 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.gnss; // This file was auto-generated from yaml/swiftnav/sbp/gnss.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class GPSTimeSec extends SBPStruct { - + /** Seconds since start of GPS week */ public long tow; - + /** GPS week number */ public int wn; + - public GPSTimeSec() {} + public GPSTimeSec () {} @Override public GPSTimeSec parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/gnss/GnssSignal.java b/java/src/com/swiftnav/sbp/gnss/GnssSignal.java index 7eb33e72d..1b35c497c 100644 --- a/java/src/com/swiftnav/sbp/gnss/GnssSignal.java +++ b/java/src/com/swiftnav/sbp/gnss/GnssSignal.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,29 +9,32 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.gnss; // This file was auto-generated from yaml/swiftnav/sbp/gnss.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class GnssSignal extends SBPStruct { - - /** - * Constellation-specific satellite id. For GLO can either be (100+FCN) where FCN is in [-7,+6] - * or the Slot ID in [1,28]. - */ + + /** Constellation-specific satellite id. For GLO can either be (100+FCN) where FCN + * is in [-7,+6] or the Slot ID in [1,28]. */ public int sat; - + /** Signal constellation, band and code */ public int code; + - public GnssSignal() {} + public GnssSignal () {} @Override public GnssSignal parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/gnss/GnssSignalDep.java b/java/src/com/swiftnav/sbp/gnss/GnssSignalDep.java index 85f8ee3d7..3a866e8fd 100644 --- a/java/src/com/swiftnav/sbp/gnss/GnssSignalDep.java +++ b/java/src/com/swiftnav/sbp/gnss/GnssSignalDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,34 +9,37 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.gnss; // This file was auto-generated from yaml/swiftnav/sbp/gnss.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class GnssSignalDep extends SBPStruct { - - /** - * Constellation-specific satellite identifier. - * - *

Note: unlike GnssSignal, GPS satellites are encoded as (PRN - 1). Other constellations do - * not have this offset. - */ + + /** Constellation-specific satellite identifier. + * + * Note: unlike GnssSignal, GPS satellites are encoded as (PRN - 1). Other + * constellations do not have this offset. */ public int sat; - + /** Signal constellation, band and code */ public int code; - + /** Reserved */ public int reserved; + - public GnssSignalDep() {} + public GnssSignalDep () {} @Override public GnssSignalDep parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/gnss/SvId.java b/java/src/com/swiftnav/sbp/gnss/SvId.java index 235c7cc3b..f72a780f1 100644 --- a/java/src/com/swiftnav/sbp/gnss/SvId.java +++ b/java/src/com/swiftnav/sbp/gnss/SvId.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,29 +9,32 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.gnss; // This file was auto-generated from yaml/swiftnav/sbp/gnss.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class SvId extends SBPStruct { - - /** - * Constellation-specific satellite id. For GLO can either be (100+FCN) where FCN is in [-7,+6] - * or the Slot ID in [1,28]. - */ + + /** Constellation-specific satellite id. For GLO can either be (100+FCN) where FCN + * is in [-7,+6] or the Slot ID in [1,28]. */ public int satId; - + /** Constellation ID to which the SV belongs */ public int constellation; + - public SvId() {} + public SvId () {} @Override public SvId parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/imu/MsgImuAux.java b/java/src/com/swiftnav/sbp/imu/MsgImuAux.java index b9dbb0f3b..0b89a6d94 100644 --- a/java/src/com/swiftnav/sbp/imu/MsgImuAux.java +++ b/java/src/com/swiftnav/sbp/imu/MsgImuAux.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,50 +9,52 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.imu; // This file was auto-generated from yaml/swiftnav/sbp/imu.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_IMU_AUX (0x0901). + +/** SBP class for message MSG_IMU_AUX (0x0901). * - *

You can have MSG_IMU_AUX inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_IMU_AUX inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Auxiliary data specific to a particular IMU. The `imu_type` field will always be consistent - * but the rest of the payload is device specific and depends on the value of `imu_type`. - */ + * Auxiliary data specific to a particular IMU. The `imu_type` field will + * always be consistent but the rest of the payload is device specific and + * depends on the value of `imu_type`. */ + public class MsgImuAux extends SBPMessage { public static final int TYPE = 0x0901; + /** IMU type */ public int imu_type; - + /** Raw IMU temperature */ public int temp; - + /** IMU configuration */ public int imu_conf; + - public MsgImuAux(int sender) { - super(sender, TYPE); - } - - public MsgImuAux() { - super(TYPE); - } - - public MsgImuAux(SBPMessage msg) throws SBPBinaryException { + public MsgImuAux (int sender) { super(sender, TYPE); } + public MsgImuAux () { super(TYPE); } + public MsgImuAux (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgImuAux, expected 2305, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgImuAux, expected 2305, actual " + msg.type); } @Override @@ -59,14 +62,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ imu_type = parser.getU8(); temp = parser.getS16(); - imu_conf = parser.getU8(); + imu_conf = parser.getU8(); } @Override protected void build(Builder builder) { builder.putU8(imu_type); builder.putS16(temp); - builder.putU8(imu_conf); + builder.putU8(imu_conf); } @Override diff --git a/java/src/com/swiftnav/sbp/imu/MsgImuComp.java b/java/src/com/swiftnav/sbp/imu/MsgImuComp.java index ae8c64286..1a4131c5f 100644 --- a/java/src/com/swiftnav/sbp/imu/MsgImuComp.java +++ b/java/src/com/swiftnav/sbp/imu/MsgImuComp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,67 +9,69 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.imu; // This file was auto-generated from yaml/swiftnav/sbp/imu.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import java.math.BigInteger; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_IMU_COMP (0x0905). +/** SBP class for message MSG_IMU_COMP (0x0905). * - *

You can have MSG_IMU_COMP inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_IMU_COMP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Data from the Inertial Measurement Unit, containing accelerometer and gyroscope readings - * compensated for estimated errors and constant physical effects. The output is valid for - * inertially referenced center of navigation (IMU body frame) represented in vehicle body frame. - */ + * Data from the Inertial Measurement Unit, containing accelerometer and + * gyroscope readings compensated for estimated errors and constant physical + * effects. The output is valid for inertially referenced center of + * navigation (IMU body frame) represented in vehicle body frame. */ + public class MsgImuComp extends SBPMessage { public static final int TYPE = 0x0905; + /** Microseconds since reference epoch */ public BigInteger time; - - /** Contains the applied compensation parameters and time synchronization mode */ + + /** Contains the applied compensation parameters and time synchronization + * mode */ public int flags; - + /** Compensated acceleration X axis */ public int acc_comp_x; - + /** Compensated acceleration Y axis */ public int acc_comp_y; - + /** Compensated acceleration Z axis */ public int acc_comp_z; - + /** Compensated angular rate X axis */ public int gyr_comp_x; - + /** Compensated angular rate Y axis */ public int gyr_comp_y; - + /** Compensated angular rate Z axis */ public int gyr_comp_z; + - public MsgImuComp(int sender) { - super(sender, TYPE); - } - - public MsgImuComp() { - super(TYPE); - } - - public MsgImuComp(SBPMessage msg) throws SBPBinaryException { + public MsgImuComp (int sender) { super(sender, TYPE); } + public MsgImuComp () { super(TYPE); } + public MsgImuComp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgImuComp, expected 2309, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgImuComp, expected 2309, actual " + msg.type); } @Override @@ -81,7 +84,7 @@ protected void parse(Parser parser) throws SBPBinaryException { acc_comp_z = parser.getS32(); gyr_comp_x = parser.getS32(); gyr_comp_y = parser.getS32(); - gyr_comp_z = parser.getS32(); + gyr_comp_z = parser.getS32(); } @Override @@ -93,7 +96,7 @@ protected void build(Builder builder) { builder.putS32(acc_comp_z); builder.putS32(gyr_comp_x); builder.putS32(gyr_comp_y); - builder.putS32(gyr_comp_z); + builder.putS32(gyr_comp_z); } @Override diff --git a/java/src/com/swiftnav/sbp/imu/MsgImuRaw.java b/java/src/com/swiftnav/sbp/imu/MsgImuRaw.java index 6b8988471..74e265469 100644 --- a/java/src/com/swiftnav/sbp/imu/MsgImuRaw.java +++ b/java/src/com/swiftnav/sbp/imu/MsgImuRaw.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,71 +9,74 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.imu; // This file was auto-generated from yaml/swiftnav/sbp/imu.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_IMU_RAW (0x0900). +/** SBP class for message MSG_IMU_RAW (0x0900). * - *

You can have MSG_IMU_RAW inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_IMU_RAW inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Raw data from the Inertial Measurement Unit, containing accelerometer and gyroscope readings. - * The sense of the measurements are to be aligned with the indications on the device itself. - * Measurement units, which are specific to the device hardware and settings, are communicated via - * the MSG_IMU_AUX message. If using "time since startup" local time tags, the receiving end will - * expect either a MSG_GNSS_TIME_OFFSET or MSG_PPS_TIME to establish the relationship between IMU - * time and GNSS time. Regardless of the timestamping mode, the timestamp is required to roll over - * to zero when reaching one week (604800 seconds, or 604800000 milliseconds). The time-tagging mode - * should not change throughout a run. - */ + * Raw data from the Inertial Measurement Unit, containing accelerometer and + * gyroscope readings. The sense of the measurements are to be aligned with + * the indications on the device itself. Measurement units, which are specific + * to the device hardware and settings, are communicated via the MSG_IMU_AUX + * message. If using "time since startup" local time tags, the receiving end + * will expect either a MSG_GNSS_TIME_OFFSET or MSG_PPS_TIME to establish the + * relationship between IMU time and GNSS time. + * Regardless of the timestamping mode, the timestamp is required to roll over + * to zero when reaching one week (604800 seconds, or 604800000 milliseconds). + * The time-tagging mode should not change throughout a run. */ + public class MsgImuRaw extends SBPMessage { public static final int TYPE = 0x0900; + /** Milliseconds since reference epoch and time status. */ public long tow; - + /** Milliseconds since reference epoch, fractional part */ public int tow_f; - + /** Acceleration in the IMU frame X axis */ public int acc_x; - + /** Acceleration in the IMU frame Y axis */ public int acc_y; - + /** Acceleration in the IMU frame Z axis */ public int acc_z; - + /** Angular rate around IMU frame X axis */ public int gyr_x; - + /** Angular rate around IMU frame Y axis */ public int gyr_y; - + /** Angular rate around IMU frame Z axis */ public int gyr_z; + - public MsgImuRaw(int sender) { - super(sender, TYPE); - } - - public MsgImuRaw() { - super(TYPE); - } - - public MsgImuRaw(SBPMessage msg) throws SBPBinaryException { + public MsgImuRaw (int sender) { super(sender, TYPE); } + public MsgImuRaw () { super(TYPE); } + public MsgImuRaw (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgImuRaw, expected 2304, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgImuRaw, expected 2304, actual " + msg.type); } @Override @@ -85,7 +89,7 @@ protected void parse(Parser parser) throws SBPBinaryException { acc_z = parser.getS16(); gyr_x = parser.getS16(); gyr_y = parser.getS16(); - gyr_z = parser.getS16(); + gyr_z = parser.getS16(); } @Override @@ -97,7 +101,7 @@ protected void build(Builder builder) { builder.putS16(acc_z); builder.putS16(gyr_x); builder.putS16(gyr_y); - builder.putS16(gyr_z); + builder.putS16(gyr_z); } @Override diff --git a/java/src/com/swiftnav/sbp/integrity/IntegritySSRHeader.java b/java/src/com/swiftnav/sbp/integrity/IntegritySSRHeader.java index 6ca184514..b6eb47ee2 100644 --- a/java/src/com/swiftnav/sbp/integrity/IntegritySSRHeader.java +++ b/java/src/com/swiftnav/sbp/integrity/IntegritySSRHeader.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,42 +9,47 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.integrity; // This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class IntegritySSRHeader extends SBPStruct { - + /** GNSS reference time of the observation used to generate the flag. */ public GPSTimeSec obs_time; - + /** Number of messages in the dataset */ public int num_msgs; - + /** Position of this message in the dataset */ public int seq_num; - + /** SSR Solution ID. */ public int ssr_sol_id; - + /** Unique identifier of the set this tile belongs to. */ public int tile_set_id; - + /** Unique identifier of this tile in the tile set. */ public int tile_id; - + /** Chain and type of flag. */ public int chain_id; + - public IntegritySSRHeader() {} + public IntegritySSRHeader () {} @Override public IntegritySSRHeader parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/integrity/MsgAcknowledge.java b/java/src/com/swiftnav/sbp/integrity/MsgAcknowledge.java index 302931247..678d89f8d 100644 --- a/java/src/com/swiftnav/sbp/integrity/MsgAcknowledge.java +++ b/java/src/com/swiftnav/sbp/integrity/MsgAcknowledge.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.integrity; // This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgAcknowledge extends SBPMessage { public static final int TYPE = 0x0BD2; - /** - * Echo of the request ID field from the corresponding CRA message, or 255 if no request ID was - * provided. - */ + + /** Echo of the request ID field from the corresponding CRA message, or + * 255 if no request ID was provided. */ public int request_id; - + /** Echo of the Area ID field from the corresponding CRA message. */ public long area_id; - + /** Reported status of the request. */ public int response_code; - - /** - * Contains the message group(s) that will be sent in response from the corresponding CRA - * correction mask. An echo of the correction mask field from the corresponding CRA message. - */ + + /** Contains the message group(s) that will be sent in response from the + * corresponding CRA correction mask. An echo of the correction mask + * field from the corresponding CRA message. */ public int correction_mask_on_demand; - + /** For future expansion. Always set to 0. */ public int correction_mask_stream; - + /** The solution ID of the instance providing the corrections. */ public int solution_id; + - public MsgAcknowledge(int sender) { - super(sender, TYPE); - } - - public MsgAcknowledge() { - super(TYPE); - } - - public MsgAcknowledge(SBPMessage msg) throws SBPBinaryException { + public MsgAcknowledge (int sender) { super(sender, TYPE); } + public MsgAcknowledge () { super(TYPE); } + public MsgAcknowledge (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAcknowledge, expected 3026, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAcknowledge, expected 3026, actual " + msg.type); } @Override @@ -69,7 +69,7 @@ protected void parse(Parser parser) throws SBPBinaryException { response_code = parser.getU8(); correction_mask_on_demand = parser.getU16(); correction_mask_stream = parser.getU16(); - solution_id = parser.getU8(); + solution_id = parser.getU8(); } @Override @@ -79,7 +79,7 @@ protected void build(Builder builder) { builder.putU8(response_code); builder.putU16(correction_mask_on_demand); builder.putU16(correction_mask_stream); - builder.putU8(solution_id); + builder.putU8(solution_id); } @Override diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java index 08f80dc75..b5bf2d262 100644 --- a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevel.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,120 +9,123 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.integrity; // This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BBA). +/** SBP class for message MSG_SSR_FLAG_HIGH_LEVEL (0x0BBA). * - *

You can have MSG_SSR_FLAG_HIGH_LEVEL inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_FLAG_HIGH_LEVEL inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Integrity monitoring flags for multiple aggregated elements. An element could be a satellite, - * SSR grid point, or SSR tile. A group of aggregated elements being monitored for integrity could - * refer to: + * Integrity monitoring flags for multiple aggregated elements. An element + * could be a satellite, SSR grid point, or SSR tile. A group of aggregated + * elements being monitored for integrity could refer to: * - *

- Satellites in a particular {GPS, GAL, BDS, QZSS} constellation. + * - Satellites in a particular {GPS, GAL, BDS, QZSS} constellation. * - *

- Satellites in the line-of-sight of a particular SSR tile. + * - Satellites in the line-of-sight of a particular SSR tile. * - *

- Satellites in the line-of-sight of a particular SSR grid point. + * - Satellites in the line-of-sight of a particular SSR grid point. * - *

The integrity usage for a group of aggregated elements varies according to the integrity flag - * of the satellites comprising that group. + * The integrity usage for a group of aggregated elements varies according to + * the integrity flag of the satellites comprising that group. * - *

SSR_INTEGRITY_USAGE_NOMINAL: All satellites received passed the integrity check and have flag - * INTEGRITY_FLAG_OK. + * SSR_INTEGRITY_USAGE_NOMINAL: All satellites received passed the integrity + * check and have flag INTEGRITY_FLAG_OK. * - *

SSR_INTEGRITY_USAGE_WARNING: A limited number of elements in the group failed the integrity - * check. Refer to more granular integrity messages for details on the specific failing elements. + * SSR_INTEGRITY_USAGE_WARNING: A limited number of elements in the group + * failed the integrity check. Refer to more granular integrity messages for + * details on the specific failing elements. * - *

SSR_INTEGRITY_USAGE_ALERT: Most elements in the group failed the integrity check, do not use - * for positioning. + * SSR_INTEGRITY_USAGE_ALERT: Most elements in the group failed the integrity + * check, do not use for positioning. * - *

SSR_INTEGRITY_USAGE_NOT_MONITORED: Unable to verify the integrity flag of elements in the - * group. - */ + * SSR_INTEGRITY_USAGE_NOT_MONITORED: Unable to verify the integrity flag of + * elements in the group. */ + public class MsgSsrFlagHighLevel extends SBPMessage { public static final int TYPE = 0x0BBA; + /** GNSS reference time of the observation used to generate the flag. */ public GPSTimeSec obs_time; - - /** GNSS reference time of the atmospheric correction associated to the flag. */ - public GPSTimeSec atmo_corr_time; - - /** GNSS reference time of the satellite correction associated to the flag. */ + + /** GNSS reference time of the ionospheric correction associated to the + * flag. */ + public GPSTimeSec iono_corr_time; + + /** GNSS reference time of the satellite correction associated to the + * flag. */ public GPSTimeSec sat_corr_time; - + /** SSR Solution ID. */ public int ssr_sol_id; - + /** Unique identifier of the set this tile belongs to. */ public int tile_set_id; - + /** Unique identifier of this tile in the tile set. */ public int tile_id; - + /** Chain and type of flag. */ public int chain_id; - + /** Use GPS satellites. */ public int use_gps_sat; - + /** Use GAL satellites. */ public int use_gal_sat; - + /** Use BDS satellites. */ public int use_bds_sat; - + /** Use QZSS satellites. */ public int use_qzss_sat; - + /** Reserved */ public int[] reserved; - + /** Use tropo grid points. */ public int use_tropo_grid_points; - + /** Use iono grid points. */ public int use_iono_grid_points; - + /** Use iono tile satellite LoS. */ public int use_iono_tile_sat_los; - + /** Use iono grid point satellite LoS. */ public int use_iono_grid_point_sat_los; + - public MsgSsrFlagHighLevel(int sender) { - super(sender, TYPE); - } - - public MsgSsrFlagHighLevel() { - super(TYPE); - } - - public MsgSsrFlagHighLevel(SBPMessage msg) throws SBPBinaryException { + public MsgSsrFlagHighLevel (int sender) { super(sender, TYPE); } + public MsgSsrFlagHighLevel () { super(TYPE); } + public MsgSsrFlagHighLevel (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrFlagHighLevel, expected 3002, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrFlagHighLevel, expected 3002, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ obs_time = new GPSTimeSec().parse(parser); - atmo_corr_time = new GPSTimeSec().parse(parser); + iono_corr_time = new GPSTimeSec().parse(parser); sat_corr_time = new GPSTimeSec().parse(parser); ssr_sol_id = parser.getU8(); tile_set_id = parser.getU16(); @@ -135,13 +139,13 @@ protected void parse(Parser parser) throws SBPBinaryException { use_tropo_grid_points = parser.getU8(); use_iono_grid_points = parser.getU8(); use_iono_tile_sat_los = parser.getU8(); - use_iono_grid_point_sat_los = parser.getU8(); + use_iono_grid_point_sat_los = parser.getU8(); } @Override protected void build(Builder builder) { obs_time.build(builder); - atmo_corr_time.build(builder); + iono_corr_time.build(builder); sat_corr_time.build(builder); builder.putU8(ssr_sol_id); builder.putU16(tile_set_id); @@ -155,14 +159,14 @@ protected void build(Builder builder) { builder.putU8(use_tropo_grid_points); builder.putU8(use_iono_grid_points); builder.putU8(use_iono_tile_sat_los); - builder.putU8(use_iono_grid_point_sat_los); + builder.putU8(use_iono_grid_point_sat_los); } @Override public JSONObject toJSON() { JSONObject obj = super.toJSON(); obj.put("obs_time", obs_time.toJSON()); - obj.put("atmo_corr_time", atmo_corr_time.toJSON()); + obj.put("iono_corr_time", iono_corr_time.toJSON()); obj.put("sat_corr_time", sat_corr_time.toJSON()); obj.put("ssr_sol_id", ssr_sol_id); obj.put("tile_set_id", tile_set_id); diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevelDepA.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevelDepA.java index cd42303ec..96e1c054c 100644 --- a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevelDepA.java +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagHighLevelDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,87 +9,87 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.integrity; // This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SSR_FLAG_HIGH_LEVEL_DEP_A (0x0BB9). +/** SBP class for message MSG_SSR_FLAG_HIGH_LEVEL_DEP_A (0x0BB9). * - *

You can have MSG_SSR_FLAG_HIGH_LEVEL_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_FLAG_HIGH_LEVEL_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSsrFlagHighLevelDepA extends SBPMessage { public static final int TYPE = 0x0BB9; + /** GNSS reference time of the observation used to generate the flag. */ public GPSTimeSec obs_time; - + /** GNSS reference time of the correction associated to the flag. */ public GPSTimeSec corr_time; - + /** SSR Solution ID. */ public int ssr_sol_id; - + /** Unique identifier of the set this tile belongs to. */ public int tile_set_id; - + /** Unique identifier of this tile in the tile set. */ public int tile_id; - + /** Chain and type of flag. */ public int chain_id; - + /** Use GPS satellites. */ public int use_gps_sat; - + /** Use GAL satellites. */ public int use_gal_sat; - + /** Use BDS satellites. */ public int use_bds_sat; - + /** Use QZSS satellites. */ public int use_qzss_sat; - + /** Reserved */ public int[] reserved; - + /** Use tropo grid points. */ public int use_tropo_grid_points; - + /** Use iono grid points. */ public int use_iono_grid_points; - + /** Use iono tile satellite LoS. */ public int use_iono_tile_sat_los; - + /** Use iono grid point satellite LoS. */ public int use_iono_grid_point_sat_los; + - public MsgSsrFlagHighLevelDepA(int sender) { - super(sender, TYPE); - } - - public MsgSsrFlagHighLevelDepA() { - super(TYPE); - } - - public MsgSsrFlagHighLevelDepA(SBPMessage msg) throws SBPBinaryException { + public MsgSsrFlagHighLevelDepA (int sender) { super(sender, TYPE); } + public MsgSsrFlagHighLevelDepA () { super(TYPE); } + public MsgSsrFlagHighLevelDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrFlagHighLevelDepA, expected 3001, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrFlagHighLevelDepA, expected 3001, actual " + msg.type); } @Override @@ -108,7 +109,7 @@ protected void parse(Parser parser) throws SBPBinaryException { use_tropo_grid_points = parser.getU8(); use_iono_grid_points = parser.getU8(); use_iono_tile_sat_los = parser.getU8(); - use_iono_grid_point_sat_los = parser.getU8(); + use_iono_grid_point_sat_los = parser.getU8(); } @Override @@ -127,7 +128,7 @@ protected void build(Builder builder) { builder.putU8(use_tropo_grid_points); builder.putU8(use_iono_grid_points); builder.putU8(use_iono_tile_sat_los); - builder.putU8(use_iono_grid_point_sat_los); + builder.putU8(use_iono_grid_point_sat_los); } @Override diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPointSatLos.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPointSatLos.java index bba530b81..db3f49405 100644 --- a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPointSatLos.java +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPointSatLos.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,47 +9,47 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.integrity; // This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgSsrFlagIonoGridPointSatLos extends SBPMessage { public static final int TYPE = 0x0BD1; + /** Header of an integrity message. */ public IntegritySSRHeader header; - + /** Index of the grid point. */ public int grid_point_id; - + /** Number of faulty LOS. */ public int n_faulty_los; - + /** List of faulty LOS */ public SvId[] faulty_los; + - public MsgSsrFlagIonoGridPointSatLos(int sender) { - super(sender, TYPE); - } - - public MsgSsrFlagIonoGridPointSatLos() { - super(TYPE); - } - - public MsgSsrFlagIonoGridPointSatLos(SBPMessage msg) throws SBPBinaryException { + public MsgSsrFlagIonoGridPointSatLos (int sender) { super(sender, TYPE); } + public MsgSsrFlagIonoGridPointSatLos () { super(TYPE); } + public MsgSsrFlagIonoGridPointSatLos (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrFlagIonoGridPointSatLos, expected 3025, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrFlagIonoGridPointSatLos, expected 3025, actual " + msg.type); } @Override @@ -57,7 +58,7 @@ protected void parse(Parser parser) throws SBPBinaryException { header = new IntegritySSRHeader().parse(parser); grid_point_id = parser.getU16(); n_faulty_los = parser.getU8(); - faulty_los = parser.getArray(SvId.class); + faulty_los = parser.getArray(SvId.class); } @Override @@ -65,7 +66,7 @@ protected void build(Builder builder) { header.build(builder); builder.putU16(grid_point_id); builder.putU8(n_faulty_los); - builder.putArray(faulty_los); + builder.putArray(faulty_los); } @Override diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPoints.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPoints.java index e95186f7f..2b13343cc 100644 --- a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPoints.java +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoGridPoints.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,44 +9,44 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.integrity; // This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgSsrFlagIonoGridPoints extends SBPMessage { public static final int TYPE = 0x0BC7; + /** Header of an integrity message. */ public IntegritySSRHeader header; - + /** Number of faulty grid points. */ public int n_faulty_points; - + /** List of faulty grid points. */ public int[] faulty_points; + - public MsgSsrFlagIonoGridPoints(int sender) { - super(sender, TYPE); - } - - public MsgSsrFlagIonoGridPoints() { - super(TYPE); - } - - public MsgSsrFlagIonoGridPoints(SBPMessage msg) throws SBPBinaryException { + public MsgSsrFlagIonoGridPoints (int sender) { super(sender, TYPE); } + public MsgSsrFlagIonoGridPoints () { super(TYPE); } + public MsgSsrFlagIonoGridPoints (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrFlagIonoGridPoints, expected 3015, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrFlagIonoGridPoints, expected 3015, actual " + msg.type); } @Override @@ -53,14 +54,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ header = new IntegritySSRHeader().parse(parser); n_faulty_points = parser.getU8(); - faulty_points = parser.getArrayofU16(); + faulty_points = parser.getArrayofU16(); } @Override protected void build(Builder builder) { header.build(builder); builder.putU8(n_faulty_points); - builder.putArrayofU16(faulty_points); + builder.putArrayofU16(faulty_points); } @Override diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoTileSatLos.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoTileSatLos.java index 010af5669..8d3861d74 100644 --- a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoTileSatLos.java +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagIonoTileSatLos.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,44 +9,44 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.integrity; // This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgSsrFlagIonoTileSatLos extends SBPMessage { public static final int TYPE = 0x0BCD; + /** Header of an integrity message. */ public IntegritySSRHeader header; - + /** Number of faulty LOS. */ public int n_faulty_los; - + /** List of faulty LOS */ public SvId[] faulty_los; + - public MsgSsrFlagIonoTileSatLos(int sender) { - super(sender, TYPE); - } - - public MsgSsrFlagIonoTileSatLos() { - super(TYPE); - } - - public MsgSsrFlagIonoTileSatLos(SBPMessage msg) throws SBPBinaryException { + public MsgSsrFlagIonoTileSatLos (int sender) { super(sender, TYPE); } + public MsgSsrFlagIonoTileSatLos () { super(TYPE); } + public MsgSsrFlagIonoTileSatLos (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrFlagIonoTileSatLos, expected 3021, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrFlagIonoTileSatLos, expected 3021, actual " + msg.type); } @Override @@ -53,14 +54,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ header = new IntegritySSRHeader().parse(parser); n_faulty_los = parser.getU8(); - faulty_los = parser.getArray(SvId.class); + faulty_los = parser.getArray(SvId.class); } @Override protected void build(Builder builder) { header.build(builder); builder.putU8(n_faulty_los); - builder.putArray(faulty_los); + builder.putArray(faulty_los); } @Override diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagSatellites.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagSatellites.java index a575692b4..c043a3311 100644 --- a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagSatellites.java +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagSatellites.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,58 +9,59 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.integrity; // This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgSsrFlagSatellites extends SBPMessage { public static final int TYPE = 0x0BBD; + /** GNSS reference time of the observation used to generate the flag. */ public GPSTimeSec obs_time; - + /** Number of messages in the dataset */ public int num_msgs; - + /** Position of this message in the dataset */ public int seq_num; - + /** SSR Solution ID. */ public int ssr_sol_id; - + /** Chain and type of flag. */ public int chain_id; - + /** Constellation ID. */ public int const_id; - + /** Number of faulty satellites. */ public int n_faulty_sats; - + /** List of faulty satellites. */ public int[] faulty_sats; + - public MsgSsrFlagSatellites(int sender) { - super(sender, TYPE); - } - - public MsgSsrFlagSatellites() { - super(TYPE); - } - - public MsgSsrFlagSatellites(SBPMessage msg) throws SBPBinaryException { + public MsgSsrFlagSatellites (int sender) { super(sender, TYPE); } + public MsgSsrFlagSatellites () { super(TYPE); } + public MsgSsrFlagSatellites (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrFlagSatellites, expected 3005, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrFlagSatellites, expected 3005, actual " + msg.type); } @Override @@ -72,7 +74,7 @@ protected void parse(Parser parser) throws SBPBinaryException { chain_id = parser.getU8(); const_id = parser.getU8(); n_faulty_sats = parser.getU8(); - faulty_sats = parser.getArrayofU8(); + faulty_sats = parser.getArrayofU8(); } @Override @@ -84,7 +86,7 @@ protected void build(Builder builder) { builder.putU8(chain_id); builder.putU8(const_id); builder.putU8(n_faulty_sats); - builder.putArrayofU8(faulty_sats); + builder.putArrayofU8(faulty_sats); } @Override diff --git a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagTropoGridPoints.java b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagTropoGridPoints.java index 31b8ae1e7..b860f2ab0 100644 --- a/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagTropoGridPoints.java +++ b/java/src/com/swiftnav/sbp/integrity/MsgSsrFlagTropoGridPoints.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,44 +9,44 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.integrity; // This file was auto-generated from yaml/swiftnav/sbp/integrity.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgSsrFlagTropoGridPoints extends SBPMessage { public static final int TYPE = 0x0BC3; + /** Header of an integrity message. */ public IntegritySSRHeader header; - + /** Number of faulty grid points. */ public int n_faulty_points; - + /** List of faulty grid points. */ public int[] faulty_points; + - public MsgSsrFlagTropoGridPoints(int sender) { - super(sender, TYPE); - } - - public MsgSsrFlagTropoGridPoints() { - super(TYPE); - } - - public MsgSsrFlagTropoGridPoints(SBPMessage msg) throws SBPBinaryException { + public MsgSsrFlagTropoGridPoints (int sender) { super(sender, TYPE); } + public MsgSsrFlagTropoGridPoints () { super(TYPE); } + public MsgSsrFlagTropoGridPoints (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrFlagTropoGridPoints, expected 3011, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrFlagTropoGridPoints, expected 3011, actual " + msg.type); } @Override @@ -53,14 +54,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ header = new IntegritySSRHeader().parse(parser); n_faulty_points = parser.getU8(); - faulty_points = parser.getArrayofU16(); + faulty_points = parser.getArrayofU16(); } @Override protected void build(Builder builder) { header.build(builder); builder.putU8(n_faulty_points); - builder.putArrayofU16(faulty_points); + builder.putArrayofU16(faulty_points); } @Override diff --git a/java/src/com/swiftnav/sbp/linux/MsgLinuxCpuState.java b/java/src/com/swiftnav/sbp/linux/MsgLinuxCpuState.java index 98960b296..8c1a18198 100644 --- a/java/src/com/swiftnav/sbp/linux/MsgLinuxCpuState.java +++ b/java/src/com/swiftnav/sbp/linux/MsgLinuxCpuState.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,62 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.linux; // This file was auto-generated from yaml/swiftnav/sbp/linux.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_LINUX_CPU_STATE (0x7F08). +/** SBP class for message MSG_LINUX_CPU_STATE (0x7F08). * - *

You can have MSG_LINUX_CPU_STATE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_LINUX_CPU_STATE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message indicates the process state of the top 10 heaviest consumers of CPU on the - * system, including a timestamp. - */ + * This message indicates the process state of the top 10 heaviest consumers + * of CPU on the system, including a timestamp. */ + public class MsgLinuxCpuState extends SBPMessage { public static final int TYPE = 0x7F08; + /** sequence of this status message, values from 0-9 */ public int index; - + /** the PID of the process */ public int pid; - + /** percent of CPU used, expressed as a fraction of 256 */ public int pcpu; - + /** timestamp of message, refer to flags field for how to interpret */ public long time; - + /** flags */ public int flags; - + /** fixed length string representing the thread name */ public String tname; - + /** the command line (as much as it fits in the remaining packet) */ public String cmdline; + - public MsgLinuxCpuState(int sender) { - super(sender, TYPE); - } - - public MsgLinuxCpuState() { - super(TYPE); - } - - public MsgLinuxCpuState(SBPMessage msg) throws SBPBinaryException { + public MsgLinuxCpuState (int sender) { super(sender, TYPE); } + public MsgLinuxCpuState () { super(TYPE); } + public MsgLinuxCpuState (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgLinuxCpuState, expected 32520, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgLinuxCpuState, expected 32520, actual " + msg.type); } @Override @@ -75,7 +77,7 @@ protected void parse(Parser parser) throws SBPBinaryException { time = parser.getU32(); flags = parser.getU8(); tname = parser.getString(15); - cmdline = parser.getString(); + cmdline = parser.getString(); } @Override @@ -86,7 +88,7 @@ protected void build(Builder builder) { builder.putU32(time); builder.putU8(flags); builder.putString(tname, 15); - builder.putString(cmdline); + builder.putString(cmdline); } @Override diff --git a/java/src/com/swiftnav/sbp/linux/MsgLinuxCpuStateDepA.java b/java/src/com/swiftnav/sbp/linux/MsgLinuxCpuStateDepA.java index c68680dbf..b144cd7d4 100644 --- a/java/src/com/swiftnav/sbp/linux/MsgLinuxCpuStateDepA.java +++ b/java/src/com/swiftnav/sbp/linux/MsgLinuxCpuStateDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.linux; // This file was auto-generated from yaml/swiftnav/sbp/linux.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_LINUX_CPU_STATE_DEP_A (0x7F00). + +/** SBP class for message MSG_LINUX_CPU_STATE_DEP_A (0x7F00). * - *

You can have MSG_LINUX_CPU_STATE_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_LINUX_CPU_STATE_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgLinuxCpuStateDepA extends SBPMessage { public static final int TYPE = 0x7F00; + /** sequence of this status message, values from 0-9 */ public int index; - + /** the PID of the process */ public int pid; - + /** percent of cpu used, expressed as a fraction of 256 */ public int pcpu; - + /** fixed length string representing the thread name */ public String tname; - + /** the command line (as much as it fits in the remaining packet) */ public String cmdline; + - public MsgLinuxCpuStateDepA(int sender) { - super(sender, TYPE); - } - - public MsgLinuxCpuStateDepA() { - super(TYPE); - } - - public MsgLinuxCpuStateDepA(SBPMessage msg) throws SBPBinaryException { + public MsgLinuxCpuStateDepA (int sender) { super(sender, TYPE); } + public MsgLinuxCpuStateDepA () { super(TYPE); } + public MsgLinuxCpuStateDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgLinuxCpuStateDepA, expected 32512, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgLinuxCpuStateDepA, expected 32512, actual " + msg.type); } @Override @@ -66,7 +68,7 @@ protected void parse(Parser parser) throws SBPBinaryException { pid = parser.getU16(); pcpu = parser.getU8(); tname = parser.getString(15); - cmdline = parser.getString(); + cmdline = parser.getString(); } @Override @@ -75,7 +77,7 @@ protected void build(Builder builder) { builder.putU16(pid); builder.putU8(pcpu); builder.putString(tname, 15); - builder.putString(cmdline); + builder.putString(cmdline); } @Override diff --git a/java/src/com/swiftnav/sbp/linux/MsgLinuxMemState.java b/java/src/com/swiftnav/sbp/linux/MsgLinuxMemState.java index 2057483ad..eb74e279e 100644 --- a/java/src/com/swiftnav/sbp/linux/MsgLinuxMemState.java +++ b/java/src/com/swiftnav/sbp/linux/MsgLinuxMemState.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,62 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.linux; // This file was auto-generated from yaml/swiftnav/sbp/linux.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_LINUX_MEM_STATE (0x7F09). +/** SBP class for message MSG_LINUX_MEM_STATE (0x7F09). * - *

You can have MSG_LINUX_MEM_STATE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_LINUX_MEM_STATE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message indicates the process state of the top 10 heaviest consumers of memory on the - * system, including a timestamp. - */ + * This message indicates the process state of the top 10 heaviest consumers + * of memory on the system, including a timestamp. */ + public class MsgLinuxMemState extends SBPMessage { public static final int TYPE = 0x7F09; + /** sequence of this status message, values from 0-9 */ public int index; - + /** the PID of the process */ public int pid; - + /** percent of memory used, expressed as a fraction of 256 */ public int pmem; - + /** timestamp of message, refer to flags field for how to interpret */ public long time; - + /** flags */ public int flags; - + /** fixed length string representing the thread name */ public String tname; - + /** the command line (as much as it fits in the remaining packet) */ public String cmdline; + - public MsgLinuxMemState(int sender) { - super(sender, TYPE); - } - - public MsgLinuxMemState() { - super(TYPE); - } - - public MsgLinuxMemState(SBPMessage msg) throws SBPBinaryException { + public MsgLinuxMemState (int sender) { super(sender, TYPE); } + public MsgLinuxMemState () { super(TYPE); } + public MsgLinuxMemState (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgLinuxMemState, expected 32521, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgLinuxMemState, expected 32521, actual " + msg.type); } @Override @@ -75,7 +77,7 @@ protected void parse(Parser parser) throws SBPBinaryException { time = parser.getU32(); flags = parser.getU8(); tname = parser.getString(15); - cmdline = parser.getString(); + cmdline = parser.getString(); } @Override @@ -86,7 +88,7 @@ protected void build(Builder builder) { builder.putU32(time); builder.putU8(flags); builder.putString(tname, 15); - builder.putString(cmdline); + builder.putString(cmdline); } @Override diff --git a/java/src/com/swiftnav/sbp/linux/MsgLinuxMemStateDepA.java b/java/src/com/swiftnav/sbp/linux/MsgLinuxMemStateDepA.java index ffba226e2..e81afea05 100644 --- a/java/src/com/swiftnav/sbp/linux/MsgLinuxMemStateDepA.java +++ b/java/src/com/swiftnav/sbp/linux/MsgLinuxMemStateDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.linux; // This file was auto-generated from yaml/swiftnav/sbp/linux.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_LINUX_MEM_STATE_DEP_A (0x7F01). + +/** SBP class for message MSG_LINUX_MEM_STATE_DEP_A (0x7F01). * - *

You can have MSG_LINUX_MEM_STATE_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_LINUX_MEM_STATE_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgLinuxMemStateDepA extends SBPMessage { public static final int TYPE = 0x7F01; + /** sequence of this status message, values from 0-9 */ public int index; - + /** the PID of the process */ public int pid; - + /** percent of memory used, expressed as a fraction of 256 */ public int pmem; - + /** fixed length string representing the thread name */ public String tname; - + /** the command line (as much as it fits in the remaining packet) */ public String cmdline; + - public MsgLinuxMemStateDepA(int sender) { - super(sender, TYPE); - } - - public MsgLinuxMemStateDepA() { - super(TYPE); - } - - public MsgLinuxMemStateDepA(SBPMessage msg) throws SBPBinaryException { + public MsgLinuxMemStateDepA (int sender) { super(sender, TYPE); } + public MsgLinuxMemStateDepA () { super(TYPE); } + public MsgLinuxMemStateDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgLinuxMemStateDepA, expected 32513, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgLinuxMemStateDepA, expected 32513, actual " + msg.type); } @Override @@ -66,7 +68,7 @@ protected void parse(Parser parser) throws SBPBinaryException { pid = parser.getU16(); pmem = parser.getU8(); tname = parser.getString(15); - cmdline = parser.getString(); + cmdline = parser.getString(); } @Override @@ -75,7 +77,7 @@ protected void build(Builder builder) { builder.putU16(pid); builder.putU8(pmem); builder.putString(tname, 15); - builder.putString(cmdline); + builder.putString(cmdline); } @Override diff --git a/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessFdCount.java b/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessFdCount.java index 1757d4694..3a5ef7f66 100644 --- a/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessFdCount.java +++ b/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessFdCount.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,52 +9,53 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.linux; // This file was auto-generated from yaml/swiftnav/sbp/linux.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_LINUX_PROCESS_FD_COUNT (0x7F06). + +/** SBP class for message MSG_LINUX_PROCESS_FD_COUNT (0x7F06). * - *

You can have MSG_LINUX_PROCESS_FD_COUNT inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_LINUX_PROCESS_FD_COUNT inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Top 10 list of processes with a large number of open file descriptors. - */ + * Top 10 list of processes with a large number of open file descriptors. */ + public class MsgLinuxProcessFdCount extends SBPMessage { public static final int TYPE = 0x7F06; + /** sequence of this status message, values from 0-9 */ public int index; - + /** the PID of the process in question */ public int pid; - + /** a count of the number of file descriptors opened by the process */ public int fd_count; - + /** the command line of the process in question */ public String cmdline; + - public MsgLinuxProcessFdCount(int sender) { - super(sender, TYPE); - } - - public MsgLinuxProcessFdCount() { - super(TYPE); - } - - public MsgLinuxProcessFdCount(SBPMessage msg) throws SBPBinaryException { + public MsgLinuxProcessFdCount (int sender) { super(sender, TYPE); } + public MsgLinuxProcessFdCount () { super(TYPE); } + public MsgLinuxProcessFdCount (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgLinuxProcessFdCount, expected 32518, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgLinuxProcessFdCount, expected 32518, actual " + msg.type); } @Override @@ -62,7 +64,7 @@ protected void parse(Parser parser) throws SBPBinaryException { index = parser.getU8(); pid = parser.getU16(); fd_count = parser.getU16(); - cmdline = parser.getString(); + cmdline = parser.getString(); } @Override @@ -70,7 +72,7 @@ protected void build(Builder builder) { builder.putU8(index); builder.putU16(pid); builder.putU16(fd_count); - builder.putString(cmdline); + builder.putString(cmdline); } @Override diff --git a/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessFdSummary.java b/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessFdSummary.java index bb68bbc73..2e3c0841e 100644 --- a/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessFdSummary.java +++ b/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessFdSummary.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,65 +9,64 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.linux; // This file was auto-generated from yaml/swiftnav/sbp/linux.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_LINUX_PROCESS_FD_SUMMARY (0x7F07). +/** SBP class for message MSG_LINUX_PROCESS_FD_SUMMARY (0x7F07). * - *

You can have MSG_LINUX_PROCESS_FD_SUMMARY inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_LINUX_PROCESS_FD_SUMMARY inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Summary of open file descriptors on the system. - */ + * Summary of open file descriptors on the system. */ + public class MsgLinuxProcessFdSummary extends SBPMessage { public static final int TYPE = 0x7F07; + /** count of total FDs open on the system */ public long sys_fd_count; - - /** - * A null delimited list of strings which alternates between a string representation of the - * process count and the file name whose count it being reported. That is, in C string syntax - * "32\0/var/log/syslog\012\0/tmp/foo\0" with the end of the list being 2 NULL terminators in a - * row. - */ + + /** A null delimited list of strings which alternates between a string + * representation of the process count and the file name whose count it + * being reported. That is, in C string syntax + * "32\0/var/log/syslog\012\0/tmp/foo\0" with the end of the list being 2 + * NULL terminators in a row. */ public String most_opened; + - public MsgLinuxProcessFdSummary(int sender) { - super(sender, TYPE); - } - - public MsgLinuxProcessFdSummary() { - super(TYPE); - } - - public MsgLinuxProcessFdSummary(SBPMessage msg) throws SBPBinaryException { + public MsgLinuxProcessFdSummary (int sender) { super(sender, TYPE); } + public MsgLinuxProcessFdSummary () { super(TYPE); } + public MsgLinuxProcessFdSummary (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgLinuxProcessFdSummary, expected 32519, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgLinuxProcessFdSummary, expected 32519, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ sys_fd_count = parser.getU32(); - most_opened = parser.getString(); + most_opened = parser.getString(); } @Override protected void build(Builder builder) { builder.putU32(sys_fd_count); - builder.putString(most_opened); + builder.putString(most_opened); } @Override diff --git a/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessSocketCounts.java b/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessSocketCounts.java index ad35e99cc..7854cd38d 100644 --- a/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessSocketCounts.java +++ b/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessSocketCounts.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,66 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.linux; // This file was auto-generated from yaml/swiftnav/sbp/linux.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_LINUX_PROCESS_SOCKET_COUNTS (0x7F03). + +/** SBP class for message MSG_LINUX_PROCESS_SOCKET_COUNTS (0x7F03). * - *

You can have MSG_LINUX_PROCESS_SOCKET_COUNTS inherent its fields directly from an inherited - * SBP object, or construct it inline using a dict of its fields. + * You can have MSG_LINUX_PROCESS_SOCKET_COUNTS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Top 10 list of processes with high socket counts. - */ + * Top 10 list of processes with high socket counts. */ + public class MsgLinuxProcessSocketCounts extends SBPMessage { public static final int TYPE = 0x7F03; + /** sequence of this status message, values from 0-9 */ public int index; - + /** the PID of the process in question */ public int pid; - + /** the number of sockets the process is using */ public int socket_count; - - /** - * A bitfield indicating the socket types used: 0x1 (tcp), 0x2 (udp), 0x4 (unix stream), 0x8 - * (unix dgram), 0x10 (netlink), and 0x8000 (unknown) - */ + + /** A bitfield indicating the socket types used: 0x1 (tcp), 0x2 (udp), 0x4 + * (unix stream), 0x8 (unix dgram), 0x10 (netlink), and 0x8000 (unknown) */ public int socket_types; - - /** - * A bitfield indicating the socket states: 0x1 (established), 0x2 (syn- sent), 0x4 (syn-recv), - * 0x8 (fin-wait-1), 0x10 (fin-wait-2), 0x20 (time-wait), 0x40 (closed), 0x80 (close-wait), - * 0x100 (last-ack), 0x200 (listen), 0x400 (closing), 0x800 (unconnected), and 0x8000 (unknown) - */ + + /** A bitfield indicating the socket states: 0x1 (established), 0x2 (syn- + * sent), 0x4 (syn-recv), 0x8 (fin-wait-1), 0x10 (fin-wait-2), 0x20 + * (time-wait), 0x40 (closed), 0x80 (close-wait), 0x100 (last-ack), 0x200 + * (listen), 0x400 (closing), 0x800 (unconnected), and 0x8000 (unknown) */ public int socket_states; - + /** the command line of the process in question */ public String cmdline; + - public MsgLinuxProcessSocketCounts(int sender) { - super(sender, TYPE); - } - - public MsgLinuxProcessSocketCounts() { - super(TYPE); - } - - public MsgLinuxProcessSocketCounts(SBPMessage msg) throws SBPBinaryException { + public MsgLinuxProcessSocketCounts (int sender) { super(sender, TYPE); } + public MsgLinuxProcessSocketCounts () { super(TYPE); } + public MsgLinuxProcessSocketCounts (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgLinuxProcessSocketCounts, expected 32515, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgLinuxProcessSocketCounts, expected 32515, actual " + msg.type); } @Override @@ -78,7 +76,7 @@ protected void parse(Parser parser) throws SBPBinaryException { socket_count = parser.getU16(); socket_types = parser.getU16(); socket_states = parser.getU16(); - cmdline = parser.getString(); + cmdline = parser.getString(); } @Override @@ -88,7 +86,7 @@ protected void build(Builder builder) { builder.putU16(socket_count); builder.putU16(socket_types); builder.putU16(socket_states); - builder.putString(cmdline); + builder.putString(cmdline); } @Override diff --git a/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessSocketQueues.java b/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessSocketQueues.java index 29a4d3527..fc57983d0 100644 --- a/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessSocketQueues.java +++ b/java/src/com/swiftnav/sbp/linux/MsgLinuxProcessSocketQueues.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,75 +9,70 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.linux; // This file was auto-generated from yaml/swiftnav/sbp/linux.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_LINUX_PROCESS_SOCKET_QUEUES (0x7F04). +/** SBP class for message MSG_LINUX_PROCESS_SOCKET_QUEUES (0x7F04). * - *

You can have MSG_LINUX_PROCESS_SOCKET_QUEUES inherent its fields directly from an inherited - * SBP object, or construct it inline using a dict of its fields. + * You can have MSG_LINUX_PROCESS_SOCKET_QUEUES inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Top 10 list of sockets with deep queues. - */ + * Top 10 list of sockets with deep queues. */ + public class MsgLinuxProcessSocketQueues extends SBPMessage { public static final int TYPE = 0x7F04; + /** sequence of this status message, values from 0-9 */ public int index; - + /** the PID of the process in question */ public int pid; - + /** the total amount of receive data queued for this process */ public int recv_queued; - + /** the total amount of send data queued for this process */ public int send_queued; - - /** - * A bitfield indicating the socket types used: 0x1 (tcp), 0x2 (udp), 0x4 (unix stream), 0x8 - * (unix dgram), 0x10 (netlink), and 0x8000 (unknown) - */ + + /** A bitfield indicating the socket types used: 0x1 (tcp), 0x2 (udp), 0x4 + * (unix stream), 0x8 (unix dgram), 0x10 (netlink), and 0x8000 (unknown) */ public int socket_types; - - /** - * A bitfield indicating the socket states: 0x1 (established), 0x2 (syn- sent), 0x4 (syn-recv), - * 0x8 (fin-wait-1), 0x10 (fin-wait-2), 0x20 (time-wait), 0x40 (closed), 0x80 (close-wait), - * 0x100 (last-ack), 0x200 (listen), 0x400 (closing), 0x800 (unconnected), and 0x8000 (unknown) - */ + + /** A bitfield indicating the socket states: 0x1 (established), 0x2 (syn- + * sent), 0x4 (syn-recv), 0x8 (fin-wait-1), 0x10 (fin-wait-2), 0x20 + * (time-wait), 0x40 (closed), 0x80 (close-wait), 0x100 (last-ack), 0x200 + * (listen), 0x400 (closing), 0x800 (unconnected), and 0x8000 (unknown) */ public int socket_states; - - /** - * Address of the largest queue, remote or local depending on the directionality of the - * connection. - */ + + /** Address of the largest queue, remote or local depending on the + * directionality of the connection. */ public String address_of_largest; - + /** the command line of the process in question */ public String cmdline; + - public MsgLinuxProcessSocketQueues(int sender) { - super(sender, TYPE); - } - - public MsgLinuxProcessSocketQueues() { - super(TYPE); - } - - public MsgLinuxProcessSocketQueues(SBPMessage msg) throws SBPBinaryException { + public MsgLinuxProcessSocketQueues (int sender) { super(sender, TYPE); } + public MsgLinuxProcessSocketQueues () { super(TYPE); } + public MsgLinuxProcessSocketQueues (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgLinuxProcessSocketQueues, expected 32516, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgLinuxProcessSocketQueues, expected 32516, actual " + msg.type); } @Override @@ -89,7 +85,7 @@ protected void parse(Parser parser) throws SBPBinaryException { socket_types = parser.getU16(); socket_states = parser.getU16(); address_of_largest = parser.getString(64); - cmdline = parser.getString(); + cmdline = parser.getString(); } @Override @@ -101,7 +97,7 @@ protected void build(Builder builder) { builder.putU16(socket_types); builder.putU16(socket_states); builder.putString(address_of_largest, 64); - builder.putString(cmdline); + builder.putString(cmdline); } @Override diff --git a/java/src/com/swiftnav/sbp/linux/MsgLinuxSocketUsage.java b/java/src/com/swiftnav/sbp/linux/MsgLinuxSocketUsage.java index d6cd9288c..77042ba37 100644 --- a/java/src/com/swiftnav/sbp/linux/MsgLinuxSocketUsage.java +++ b/java/src/com/swiftnav/sbp/linux/MsgLinuxSocketUsage.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,59 +9,57 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.linux; // This file was auto-generated from yaml/swiftnav/sbp/linux.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_LINUX_SOCKET_USAGE (0x7F05). + +/** SBP class for message MSG_LINUX_SOCKET_USAGE (0x7F05). * - *

You can have MSG_LINUX_SOCKET_USAGE inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_LINUX_SOCKET_USAGE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Summaries the socket usage across the system. - */ + * Summaries the socket usage across the system. */ + public class MsgLinuxSocketUsage extends SBPMessage { public static final int TYPE = 0x7F05; + /** average socket queue depths across all sockets on the system */ public long avg_queue_depth; - + /** the max queue depth seen within the reporting period */ public long max_queue_depth; - - /** - * A count for each socket type reported in the `socket_types_reported` field, the first entry - * corresponds to the first enabled bit in `types_reported`. - */ + + /** A count for each socket type reported in the `socket_types_reported` + * field, the first entry corresponds to the first enabled bit in + * `types_reported`. */ public int[] socket_state_counts; - - /** - * A count for each socket type reported in the `socket_types_reported` field, the first entry - * corresponds to the first enabled bit in `types_reported`. - */ + + /** A count for each socket type reported in the `socket_types_reported` + * field, the first entry corresponds to the first enabled bit in + * `types_reported`. */ public int[] socket_type_counts; + - public MsgLinuxSocketUsage(int sender) { - super(sender, TYPE); - } - - public MsgLinuxSocketUsage() { - super(TYPE); - } - - public MsgLinuxSocketUsage(SBPMessage msg) throws SBPBinaryException { + public MsgLinuxSocketUsage (int sender) { super(sender, TYPE); } + public MsgLinuxSocketUsage () { super(TYPE); } + public MsgLinuxSocketUsage (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgLinuxSocketUsage, expected 32517, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgLinuxSocketUsage, expected 32517, actual " + msg.type); } @Override @@ -69,7 +68,7 @@ protected void parse(Parser parser) throws SBPBinaryException { avg_queue_depth = parser.getU32(); max_queue_depth = parser.getU32(); socket_state_counts = parser.getArrayofU16(16); - socket_type_counts = parser.getArrayofU16(16); + socket_type_counts = parser.getArrayofU16(16); } @Override @@ -77,7 +76,7 @@ protected void build(Builder builder) { builder.putU32(avg_queue_depth); builder.putU32(max_queue_depth); builder.putArrayofU16(socket_state_counts, 16); - builder.putArrayofU16(socket_type_counts, 16); + builder.putArrayofU16(socket_type_counts, 16); } @Override diff --git a/java/src/com/swiftnav/sbp/linux/MsgLinuxSysState.java b/java/src/com/swiftnav/sbp/linux/MsgLinuxSysState.java index 369b7ba58..d40ea8bdb 100644 --- a/java/src/com/swiftnav/sbp/linux/MsgLinuxSysState.java +++ b/java/src/com/swiftnav/sbp/linux/MsgLinuxSysState.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,64 +9,66 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.linux; // This file was auto-generated from yaml/swiftnav/sbp/linux.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_LINUX_SYS_STATE (0x7F0A). +/** SBP class for message MSG_LINUX_SYS_STATE (0x7F0A). * - *

You can have MSG_LINUX_SYS_STATE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_LINUX_SYS_STATE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This presents a summary of CPU and memory utilization, including a timestamp. - */ + * This presents a summary of CPU and memory utilization, including a + * timestamp. */ + public class MsgLinuxSysState extends SBPMessage { public static final int TYPE = 0x7F0A; + /** total system memory, in MiB */ public int mem_total; - + /** percent of CPU used, expressed as a fraction of 256 */ public int pcpu; - + /** percent of memory used, expressed as a fraction of 256 */ public int pmem; - + /** number of processes that started during collection phase */ public int procs_starting; - + /** number of processes that stopped during collection phase */ public int procs_stopping; - + /** the count of processes on the system */ public int pid_count; - + /** timestamp of message, refer to flags field for how to interpret */ public long time; - + /** flags */ public int flags; + - public MsgLinuxSysState(int sender) { - super(sender, TYPE); - } - - public MsgLinuxSysState() { - super(TYPE); - } - - public MsgLinuxSysState(SBPMessage msg) throws SBPBinaryException { + public MsgLinuxSysState (int sender) { super(sender, TYPE); } + public MsgLinuxSysState () { super(TYPE); } + public MsgLinuxSysState (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgLinuxSysState, expected 32522, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgLinuxSysState, expected 32522, actual " + msg.type); } @Override @@ -78,7 +81,7 @@ protected void parse(Parser parser) throws SBPBinaryException { procs_stopping = parser.getU16(); pid_count = parser.getU16(); time = parser.getU32(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -90,7 +93,7 @@ protected void build(Builder builder) { builder.putU16(procs_stopping); builder.putU16(pid_count); builder.putU32(time); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/linux/MsgLinuxSysStateDepA.java b/java/src/com/swiftnav/sbp/linux/MsgLinuxSysStateDepA.java index 82b1718c0..50843569e 100644 --- a/java/src/com/swiftnav/sbp/linux/MsgLinuxSysStateDepA.java +++ b/java/src/com/swiftnav/sbp/linux/MsgLinuxSysStateDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,58 +9,59 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.linux; // This file was auto-generated from yaml/swiftnav/sbp/linux.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_LINUX_SYS_STATE_DEP_A (0x7F02). + +/** SBP class for message MSG_LINUX_SYS_STATE_DEP_A (0x7F02). * - *

You can have MSG_LINUX_SYS_STATE_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_LINUX_SYS_STATE_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgLinuxSysStateDepA extends SBPMessage { public static final int TYPE = 0x7F02; + /** total system memory */ public int mem_total; - + /** percent of total cpu currently utilized */ public int pcpu; - + /** percent of total memory currently utilized */ public int pmem; - + /** number of processes that started during collection phase */ public int procs_starting; - + /** number of processes that stopped during collection phase */ public int procs_stopping; - + /** the count of processes on the system */ public int pid_count; + - public MsgLinuxSysStateDepA(int sender) { - super(sender, TYPE); - } - - public MsgLinuxSysStateDepA() { - super(TYPE); - } - - public MsgLinuxSysStateDepA(SBPMessage msg) throws SBPBinaryException { + public MsgLinuxSysStateDepA (int sender) { super(sender, TYPE); } + public MsgLinuxSysStateDepA () { super(TYPE); } + public MsgLinuxSysStateDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgLinuxSysStateDepA, expected 32514, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgLinuxSysStateDepA, expected 32514, actual " + msg.type); } @Override @@ -70,7 +72,7 @@ protected void parse(Parser parser) throws SBPBinaryException { pmem = parser.getU8(); procs_starting = parser.getU16(); procs_stopping = parser.getU16(); - pid_count = parser.getU16(); + pid_count = parser.getU16(); } @Override @@ -80,7 +82,7 @@ protected void build(Builder builder) { builder.putU8(pmem); builder.putU16(procs_starting); builder.putU16(procs_stopping); - builder.putU16(pid_count); + builder.putU16(pid_count); } @Override diff --git a/java/src/com/swiftnav/sbp/logging/MsgFwd.java b/java/src/com/swiftnav/sbp/logging/MsgFwd.java index a6038e738..90cef2db8 100644 --- a/java/src/com/swiftnav/sbp/logging/MsgFwd.java +++ b/java/src/com/swiftnav/sbp/logging/MsgFwd.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,57 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.logging; // This file was auto-generated from yaml/swiftnav/sbp/logging.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_FWD (0x0402). + +/** SBP class for message MSG_FWD (0x0402). * - *

You can have MSG_FWD inherent its fields directly from an inherited SBP object, or construct - * it inline using a dict of its fields. + * You can have MSG_FWD inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message provides the ability to forward messages over SBP. This may take the form of - * wrapping up SBP messages received by Piksi for logging purposes or wrapping another protocol with - * SBP. + * This message provides the ability to forward messages over SBP. This may + * take the form of wrapping up SBP messages received by Piksi for logging + * purposes or wrapping another protocol with SBP. * - *

The source identifier indicates from what interface a forwarded stream derived. The protocol - * identifier identifies what the expected protocol the forwarded msg contains. Protocol 0 - * represents SBP and the remaining values are implementation defined. - */ + * The source identifier indicates from what interface a forwarded stream + * derived. The protocol identifier identifies what the expected protocol the + * forwarded msg contains. Protocol 0 represents SBP and the remaining values + * are implementation defined. */ + public class MsgFwd extends SBPMessage { public static final int TYPE = 0x0402; + /** source identifier */ public int source; - + /** protocol identifier */ public int protocol; - + /** variable length wrapped binary message */ public int[] fwd_payload; + - public MsgFwd(int sender) { - super(sender, TYPE); - } - - public MsgFwd() { - super(TYPE); - } - - public MsgFwd(SBPMessage msg) throws SBPBinaryException { + public MsgFwd (int sender) { super(sender, TYPE); } + public MsgFwd () { super(TYPE); } + public MsgFwd (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFwd, expected 1026, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFwd, expected 1026, actual " + msg.type); } @Override @@ -65,14 +67,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ source = parser.getU8(); protocol = parser.getU8(); - fwd_payload = parser.getArrayofU8(); + fwd_payload = parser.getArrayofU8(); } @Override protected void build(Builder builder) { builder.putU8(source); builder.putU8(protocol); - builder.putArrayofU8(fwd_payload); + builder.putArrayofU8(fwd_payload); } @Override diff --git a/java/src/com/swiftnav/sbp/logging/MsgLog.java b/java/src/com/swiftnav/sbp/logging/MsgLog.java index c074fa11f..eae060b8d 100644 --- a/java/src/com/swiftnav/sbp/logging/MsgLog.java +++ b/java/src/com/swiftnav/sbp/logging/MsgLog.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.logging; // This file was auto-generated from yaml/swiftnav/sbp/logging.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_LOG (0x0401). +/** SBP class for message MSG_LOG (0x0401). * - *

You can have MSG_LOG inherent its fields directly from an inherited SBP object, or construct - * it inline using a dict of its fields. + * You can have MSG_LOG inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message contains a human-readable payload string from the device containing errors, - * warnings and informational messages at ERROR, WARNING, DEBUG, INFO logging levels. - */ + * This message contains a human-readable payload string from the device + * containing errors, warnings and informational messages at ERROR, WARNING, + * DEBUG, INFO logging levels. */ + public class MsgLog extends SBPMessage { public static final int TYPE = 0x0401; + /** Logging level */ public int level; - + /** Human-readable string */ public String text; + - public MsgLog(int sender) { - super(sender, TYPE); - } - - public MsgLog() { - super(TYPE); - } - - public MsgLog(SBPMessage msg) throws SBPBinaryException { + public MsgLog (int sender) { super(sender, TYPE); } + public MsgLog () { super(TYPE); } + public MsgLog (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgLog, expected 1025, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgLog, expected 1025, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ level = parser.getU8(); - text = parser.getString(); + text = parser.getString(); } @Override protected void build(Builder builder) { builder.putU8(level); - builder.putString(text); + builder.putString(text); } @Override diff --git a/java/src/com/swiftnav/sbp/logging/MsgPrintDep.java b/java/src/com/swiftnav/sbp/logging/MsgPrintDep.java index 2fbda0594..e08f917c1 100644 --- a/java/src/com/swiftnav/sbp/logging/MsgPrintDep.java +++ b/java/src/com/swiftnav/sbp/logging/MsgPrintDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,54 +9,55 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.logging; // This file was auto-generated from yaml/swiftnav/sbp/logging.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_PRINT_DEP (0x0010). +/** SBP class for message MSG_PRINT_DEP (0x0010). * - *

You can have MSG_PRINT_DEP inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_PRINT_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgPrintDep extends SBPMessage { public static final int TYPE = 0x0010; + /** Human-readable string */ public String text; + - public MsgPrintDep(int sender) { - super(sender, TYPE); - } - - public MsgPrintDep() { - super(TYPE); - } - - public MsgPrintDep(SBPMessage msg) throws SBPBinaryException { + public MsgPrintDep (int sender) { super(sender, TYPE); } + public MsgPrintDep () { super(TYPE); } + public MsgPrintDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPrintDep, expected 16, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPrintDep, expected 16, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - text = parser.getString(); + text = parser.getString(); } @Override protected void build(Builder builder) { - builder.putString(text); + builder.putString(text); } @Override diff --git a/java/src/com/swiftnav/sbp/mag/MsgMagRaw.java b/java/src/com/swiftnav/sbp/mag/MsgMagRaw.java index d1daafe57..d66a35fb4 100644 --- a/java/src/com/swiftnav/sbp/mag/MsgMagRaw.java +++ b/java/src/com/swiftnav/sbp/mag/MsgMagRaw.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,57 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.mag; // This file was auto-generated from yaml/swiftnav/sbp/mag.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_MAG_RAW (0x0902). + +/** SBP class for message MSG_MAG_RAW (0x0902). * - *

You can have MSG_MAG_RAW inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_MAG_RAW inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Raw data from the magnetometer. - */ + * Raw data from the magnetometer. */ + public class MsgMagRaw extends SBPMessage { public static final int TYPE = 0x0902; - /** - * Milliseconds since start of GPS week. If the high bit is set, the time is unknown or invalid. - */ + + /** Milliseconds since start of GPS week. If the high bit is set, the time + * is unknown or invalid. */ public long tow; - + /** Milliseconds since start of GPS week, fractional part */ public int tow_f; - + /** Magnetic field in the body frame X axis */ public int mag_x; - + /** Magnetic field in the body frame Y axis */ public int mag_y; - + /** Magnetic field in the body frame Z axis */ public int mag_z; + - public MsgMagRaw(int sender) { - super(sender, TYPE); - } - - public MsgMagRaw() { - super(TYPE); - } - - public MsgMagRaw(SBPMessage msg) throws SBPBinaryException { + public MsgMagRaw (int sender) { super(sender, TYPE); } + public MsgMagRaw () { super(TYPE); } + public MsgMagRaw (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgMagRaw, expected 2306, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgMagRaw, expected 2306, actual " + msg.type); } @Override @@ -68,7 +69,7 @@ protected void parse(Parser parser) throws SBPBinaryException { tow_f = parser.getU8(); mag_x = parser.getS16(); mag_y = parser.getS16(); - mag_z = parser.getS16(); + mag_z = parser.getS16(); } @Override @@ -77,7 +78,7 @@ protected void build(Builder builder) { builder.putU8(tow_f); builder.putS16(mag_x); builder.putS16(mag_y); - builder.putS16(mag_z); + builder.putS16(mag_z); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/EstimatedHorizontalErrorEllipse.java b/java/src/com/swiftnav/sbp/navigation/EstimatedHorizontalErrorEllipse.java index 585c2dff8..2a0447b25 100644 --- a/java/src/com/swiftnav/sbp/navigation/EstimatedHorizontalErrorEllipse.java +++ b/java/src/com/swiftnav/sbp/navigation/EstimatedHorizontalErrorEllipse.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,42 +9,40 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class EstimatedHorizontalErrorEllipse extends SBPStruct { - - /** - * The semi major axis of the estimated horizontal error ellipse at the user- configured - * confidence level; zero implies invalid. - */ + + /** The semi major axis of the estimated horizontal error ellipse at the user- + * configured confidence level; zero implies invalid. */ public float semi_major; - - /** - * The semi minor axis of the estimated horizontal error ellipse at the user- configured - * confidence level; zero implies invalid. - */ + + /** The semi minor axis of the estimated horizontal error ellipse at the user- + * configured confidence level; zero implies invalid. */ public float semi_minor; - - /** - * The orientation of the semi major axis of the estimated horizontal error ellipse with respect - * to North. - */ + + /** The orientation of the semi major axis of the estimated horizontal error + * ellipse with respect to North. */ public float orientation; + - public EstimatedHorizontalErrorEllipse() {} + public EstimatedHorizontalErrorEllipse () {} @Override - public EstimatedHorizontalErrorEllipse parse(SBPMessage.Parser parser) - throws SBPBinaryException { + public EstimatedHorizontalErrorEllipse parse(SBPMessage.Parser parser) throws SBPBinaryException { /* Parse fields from binary */ semi_major = parser.getFloat(); semi_minor = parser.getFloat(); diff --git a/java/src/com/swiftnav/sbp/navigation/MsgAgeCorrections.java b/java/src/com/swiftnav/sbp/navigation/MsgAgeCorrections.java index 88322ce54..dfd209296 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgAgeCorrections.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgAgeCorrections.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,59 +9,61 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_AGE_CORRECTIONS (0x0210). +/** SBP class for message MSG_AGE_CORRECTIONS (0x0210). * - *

You can have MSG_AGE_CORRECTIONS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_AGE_CORRECTIONS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the Age of the corrections used for the current Differential solution. - */ + * This message reports the Age of the corrections used for the current + * Differential solution. */ + public class MsgAgeCorrections extends SBPMessage { public static final int TYPE = 0x0210; + /** GPS Time of Week */ public long tow; - + /** Age of the corrections (0xFFFF indicates invalid) */ public int age; + - public MsgAgeCorrections(int sender) { - super(sender, TYPE); - } - - public MsgAgeCorrections() { - super(TYPE); - } - - public MsgAgeCorrections(SBPMessage msg) throws SBPBinaryException { + public MsgAgeCorrections (int sender) { super(sender, TYPE); } + public MsgAgeCorrections () { super(TYPE); } + public MsgAgeCorrections (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAgeCorrections, expected 528, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAgeCorrections, expected 528, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ tow = parser.getU32(); - age = parser.getU16(); + age = parser.getU16(); } @Override protected void build(Builder builder) { builder.putU32(tow); - builder.putU16(age); + builder.putU16(age); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgBaselineECEF.java b/java/src/com/swiftnav/sbp/navigation/MsgBaselineECEF.java index e73dce1eb..c2f452000 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgBaselineECEF.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgBaselineECEF.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,65 +9,67 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_BASELINE_ECEF (0x020B). +/** SBP class for message MSG_BASELINE_ECEF (0x020B). * - *

You can have MSG_BASELINE_ECEF inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_BASELINE_ECEF inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the baseline solution in Earth Centered Earth Fixed (ECEF) coordinates. - * This baseline is the relative vector distance from the base station to the rover receiver. The - * full GPS time is given by the preceding MSG_GPS_TIME with the matching time-of-week (tow). + * This message reports the baseline solution in Earth Centered Earth Fixed + * (ECEF) coordinates. This baseline is the relative vector distance from the + * base station to the rover receiver. The full GPS time is given by the + * preceding MSG_GPS_TIME with the matching time-of-week (tow). * - *

The values in this message are from GNSS measurements only. - */ + * The values in this message are from GNSS measurements only. */ + public class MsgBaselineECEF extends SBPMessage { public static final int TYPE = 0x020B; + /** GPS Time of Week */ public long tow; - + /** Baseline ECEF X coordinate */ public int x; - + /** Baseline ECEF Y coordinate */ public int y; - + /** Baseline ECEF Z coordinate */ public int z; - + /** Position estimated standard deviation */ public int accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgBaselineECEF(int sender) { - super(sender, TYPE); - } - - public MsgBaselineECEF() { - super(TYPE); - } - - public MsgBaselineECEF(SBPMessage msg) throws SBPBinaryException { + public MsgBaselineECEF (int sender) { super(sender, TYPE); } + public MsgBaselineECEF () { super(TYPE); } + public MsgBaselineECEF (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgBaselineECEF, expected 523, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgBaselineECEF, expected 523, actual " + msg.type); } @Override @@ -78,7 +81,7 @@ protected void parse(Parser parser) throws SBPBinaryException { z = parser.getS32(); accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -89,7 +92,7 @@ protected void build(Builder builder) { builder.putS32(z); builder.putU16(accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgBaselineECEFDepA.java b/java/src/com/swiftnav/sbp/navigation/MsgBaselineECEFDepA.java index 5eff0b851..f84c4f196 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgBaselineECEFDepA.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgBaselineECEFDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_BASELINE_ECEF_DEP_A (0x0202). +/** SBP class for message MSG_BASELINE_ECEF_DEP_A (0x0202). * - *

You can have MSG_BASELINE_ECEF_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_BASELINE_ECEF_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgBaselineECEFDepA extends SBPMessage { public static final int TYPE = 0x0202; + /** GPS Time of Week */ public long tow; - + /** Baseline ECEF X coordinate */ public int x; - + /** Baseline ECEF Y coordinate */ public int y; - + /** Baseline ECEF Z coordinate */ public int z; - + /** Position accuracy estimate */ public int accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgBaselineECEFDepA(int sender) { - super(sender, TYPE); - } - - public MsgBaselineECEFDepA() { - super(TYPE); - } - - public MsgBaselineECEFDepA(SBPMessage msg) throws SBPBinaryException { + public MsgBaselineECEFDepA (int sender) { super(sender, TYPE); } + public MsgBaselineECEFDepA () { super(TYPE); } + public MsgBaselineECEFDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgBaselineECEFDepA, expected 514, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgBaselineECEFDepA, expected 514, actual " + msg.type); } @Override @@ -74,7 +76,7 @@ protected void parse(Parser parser) throws SBPBinaryException { z = parser.getS32(); accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -85,7 +87,7 @@ protected void build(Builder builder) { builder.putS32(z); builder.putU16(accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgBaselineHeadingDepA.java b/java/src/com/swiftnav/sbp/navigation/MsgBaselineHeadingDepA.java index dfb7aeece..caab27d80 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgBaselineHeadingDepA.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgBaselineHeadingDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,52 +9,53 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_BASELINE_HEADING_DEP_A (0x0207). + +/** SBP class for message MSG_BASELINE_HEADING_DEP_A (0x0207). * - *

You can have MSG_BASELINE_HEADING_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_BASELINE_HEADING_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgBaselineHeadingDepA extends SBPMessage { public static final int TYPE = 0x0207; + /** GPS Time of Week */ public long tow; - + /** Heading */ public long heading; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgBaselineHeadingDepA(int sender) { - super(sender, TYPE); - } - - public MsgBaselineHeadingDepA() { - super(TYPE); - } - - public MsgBaselineHeadingDepA(SBPMessage msg) throws SBPBinaryException { + public MsgBaselineHeadingDepA (int sender) { super(sender, TYPE); } + public MsgBaselineHeadingDepA () { super(TYPE); } + public MsgBaselineHeadingDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgBaselineHeadingDepA, expected 519, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgBaselineHeadingDepA, expected 519, actual " + msg.type); } @Override @@ -62,7 +64,7 @@ protected void parse(Parser parser) throws SBPBinaryException { tow = parser.getU32(); heading = parser.getU32(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -70,7 +72,7 @@ protected void build(Builder builder) { builder.putU32(tow); builder.putU32(heading); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgBaselineNED.java b/java/src/com/swiftnav/sbp/navigation/MsgBaselineNED.java index d081a65c2..af0b26af6 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgBaselineNED.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgBaselineNED.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,69 +9,72 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_BASELINE_NED (0x020C). +/** SBP class for message MSG_BASELINE_NED (0x020C). * - *

You can have MSG_BASELINE_NED inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_BASELINE_NED inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the baseline solution in North East Down (NED) coordinates. This baseline - * is the relative vector distance from the base station to the rover receiver, and NED coordinate - * system is defined at the local WGS84 tangent plane centered at the base station position. The - * full GPS time is given by the preceding MSG_GPS_TIME with the matching time-of- week (tow). + * This message reports the baseline solution in North East Down (NED) + * coordinates. This baseline is the relative vector distance from the base + * station to the rover receiver, and NED coordinate system is defined at the + * local WGS84 tangent plane centered at the base station position. The full + * GPS time is given by the preceding MSG_GPS_TIME with the matching time-of- + * week (tow). * - *

The values in this message are from GNSS measurements only. - */ + * The values in this message are from GNSS measurements only. */ + public class MsgBaselineNED extends SBPMessage { public static final int TYPE = 0x020C; + /** GPS Time of Week */ public long tow; - + /** Baseline North coordinate */ public int n; - + /** Baseline East coordinate */ public int e; - + /** Baseline Down coordinate */ public int d; - + /** Horizontal position estimated standard deviation */ public int h_accuracy; - + /** Vertical position estimated standard deviation */ public int v_accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgBaselineNED(int sender) { - super(sender, TYPE); - } - - public MsgBaselineNED() { - super(TYPE); - } - - public MsgBaselineNED(SBPMessage msg) throws SBPBinaryException { + public MsgBaselineNED (int sender) { super(sender, TYPE); } + public MsgBaselineNED () { super(TYPE); } + public MsgBaselineNED (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgBaselineNED, expected 524, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgBaselineNED, expected 524, actual " + msg.type); } @Override @@ -83,7 +87,7 @@ protected void parse(Parser parser) throws SBPBinaryException { h_accuracy = parser.getU16(); v_accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -95,7 +99,7 @@ protected void build(Builder builder) { builder.putU16(h_accuracy); builder.putU16(v_accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgBaselineNEDDepA.java b/java/src/com/swiftnav/sbp/navigation/MsgBaselineNEDDepA.java index 310f90de6..3ce3779fc 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgBaselineNEDDepA.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgBaselineNEDDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,64 +9,66 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_BASELINE_NED_DEP_A (0x0203). +/** SBP class for message MSG_BASELINE_NED_DEP_A (0x0203). * - *

You can have MSG_BASELINE_NED_DEP_A inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_BASELINE_NED_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgBaselineNEDDepA extends SBPMessage { public static final int TYPE = 0x0203; + /** GPS Time of Week */ public long tow; - + /** Baseline North coordinate */ public int n; - + /** Baseline East coordinate */ public int e; - + /** Baseline Down coordinate */ public int d; - - /** Horizontal position accuracy estimate (not implemented). Defaults to 0. */ + + /** Horizontal position accuracy estimate (not implemented). Defaults to + * 0. */ public int h_accuracy; - + /** Vertical position accuracy estimate (not implemented). Defaults to 0. */ public int v_accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgBaselineNEDDepA(int sender) { - super(sender, TYPE); - } - - public MsgBaselineNEDDepA() { - super(TYPE); - } - - public MsgBaselineNEDDepA(SBPMessage msg) throws SBPBinaryException { + public MsgBaselineNEDDepA (int sender) { super(sender, TYPE); } + public MsgBaselineNEDDepA () { super(TYPE); } + public MsgBaselineNEDDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgBaselineNEDDepA, expected 515, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgBaselineNEDDepA, expected 515, actual " + msg.type); } @Override @@ -78,7 +81,7 @@ protected void parse(Parser parser) throws SBPBinaryException { h_accuracy = parser.getU16(); v_accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -90,7 +93,7 @@ protected void build(Builder builder) { builder.putU16(h_accuracy); builder.putU16(v_accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgDops.java b/java/src/com/swiftnav/sbp/navigation/MsgDops.java index aa392260c..372e0336f 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgDops.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgDops.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,65 +9,68 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_DOPS (0x0208). +/** SBP class for message MSG_DOPS (0x0208). * - *

You can have MSG_DOPS inherent its fields directly from an inherited SBP object, or construct - * it inline using a dict of its fields. + * You can have MSG_DOPS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This dilution of precision (DOP) message describes the effect of navigation satellite geometry - * on positional measurement precision. The flags field indicated whether the DOP reported - * corresponds to differential or SPP solution. + * This dilution of precision (DOP) message describes the effect of navigation + * satellite geometry on positional measurement precision. The flags field + * indicated whether the DOP reported corresponds to differential or SPP + * solution. * - *

The values in this message are from GNSS measurements only. - */ + * The values in this message are from GNSS measurements only. */ + public class MsgDops extends SBPMessage { public static final int TYPE = 0x0208; + /** GPS Time of Week */ public long tow; - + /** Geometric Dilution of Precision */ public int gdop; - + /** Position Dilution of Precision */ public int pdop; - + /** Time Dilution of Precision */ public int tdop; - + /** Horizontal Dilution of Precision */ public int hdop; - + /** Vertical Dilution of Precision */ public int vdop; - - /** Indicates the position solution with which the DOPS message corresponds */ + + /** Indicates the position solution with which the DOPS message + * corresponds */ public int flags; + - public MsgDops(int sender) { - super(sender, TYPE); - } - - public MsgDops() { - super(TYPE); - } - - public MsgDops(SBPMessage msg) throws SBPBinaryException { + public MsgDops (int sender) { super(sender, TYPE); } + public MsgDops () { super(TYPE); } + public MsgDops (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgDops, expected 520, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgDops, expected 520, actual " + msg.type); } @Override @@ -78,7 +82,7 @@ protected void parse(Parser parser) throws SBPBinaryException { tdop = parser.getU16(); hdop = parser.getU16(); vdop = parser.getU16(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -89,7 +93,7 @@ protected void build(Builder builder) { builder.putU16(tdop); builder.putU16(hdop); builder.putU16(vdop); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgDopsDepA.java b/java/src/com/swiftnav/sbp/navigation/MsgDopsDepA.java index 3fe3a955f..6d575e35f 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgDopsDepA.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgDopsDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,58 +9,59 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_DOPS_DEP_A (0x0206). + +/** SBP class for message MSG_DOPS_DEP_A (0x0206). * - *

You can have MSG_DOPS_DEP_A inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_DOPS_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgDopsDepA extends SBPMessage { public static final int TYPE = 0x0206; + /** GPS Time of Week */ public long tow; - + /** Geometric Dilution of Precision */ public int gdop; - + /** Position Dilution of Precision */ public int pdop; - + /** Time Dilution of Precision */ public int tdop; - + /** Horizontal Dilution of Precision */ public int hdop; - + /** Vertical Dilution of Precision */ public int vdop; + - public MsgDopsDepA(int sender) { - super(sender, TYPE); - } - - public MsgDopsDepA() { - super(TYPE); - } - - public MsgDopsDepA(SBPMessage msg) throws SBPBinaryException { + public MsgDopsDepA (int sender) { super(sender, TYPE); } + public MsgDopsDepA () { super(TYPE); } + public MsgDopsDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgDopsDepA, expected 518, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgDopsDepA, expected 518, actual " + msg.type); } @Override @@ -70,7 +72,7 @@ protected void parse(Parser parser) throws SBPBinaryException { pdop = parser.getU16(); tdop = parser.getU16(); hdop = parser.getU16(); - vdop = parser.getU16(); + vdop = parser.getU16(); } @Override @@ -80,7 +82,7 @@ protected void build(Builder builder) { builder.putU16(pdop); builder.putU16(tdop); builder.putU16(hdop); - builder.putU16(vdop); + builder.putU16(vdop); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgGPSTime.java b/java/src/com/swiftnav/sbp/navigation/MsgGPSTime.java index e3cb5ec48..8087aa17b 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgGPSTime.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgGPSTime.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,63 +9,68 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_GPS_TIME (0x0102). + +/** SBP class for message MSG_GPS_TIME (0x0102). * - *

You can have MSG_GPS_TIME inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_GPS_TIME inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the GPS time, representing the time since the GPS epoch began on midnight - * January 6, 1980 UTC. GPS time counts the weeks and seconds of the week. The weeks begin at the - * Saturday/Sunday transition. GPS week 0 began at the beginning of the GPS time scale. + * This message reports the GPS time, representing the time since the GPS + * epoch began on midnight January 6, 1980 UTC. GPS time counts the weeks and + * seconds of the week. The weeks begin at the Saturday/Sunday transition. GPS + * week 0 began at the beginning of the GPS time scale. * - *

Within each week number, the GPS time of the week is between between 0 and 604800 seconds - * (=60*60*24*7). Note that GPS time does not accumulate leap seconds, and as of now, has a small - * offset from UTC. In a message stream, this message precedes a set of other navigation messages - * referenced to the same time (but lacking the ns field) and indicates a more precise time of these - * messages. + * Within each week number, the GPS time of the week is between between 0 and + * 604800 seconds (=60*60*24*7). Note that GPS time does not accumulate leap + * seconds, and as of now, has a small offset from UTC. In a message stream, + * this message precedes a set of other navigation messages referenced to the + * same time (but lacking the ns field) and indicates a more precise time of + * these messages. * - *

The values in this message are from GNSS measurements fused with inertial measurements. To get - * values from GNSS measurements only use MSG_GPS_TIME_GNSS. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. To get values from GNSS measurements only use + * MSG_GPS_TIME_GNSS. */ + public class MsgGPSTime extends SBPMessage { public static final int TYPE = 0x0102; + /** GPS week number */ public int wn; - + /** GPS time of week rounded to the nearest millisecond */ public long tow; - - /** Nanosecond residual of millisecond-rounded TOW (ranges from -500000 to 500000) */ + + /** Nanosecond residual of millisecond-rounded TOW (ranges from -500000 to + * 500000) */ public int ns_residual; - + /** Status flags (reserved) */ public int flags; + - public MsgGPSTime(int sender) { - super(sender, TYPE); - } - - public MsgGPSTime() { - super(TYPE); - } - - public MsgGPSTime(SBPMessage msg) throws SBPBinaryException { + public MsgGPSTime (int sender) { super(sender, TYPE); } + public MsgGPSTime () { super(TYPE); } + public MsgGPSTime (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgGPSTime, expected 258, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgGPSTime, expected 258, actual " + msg.type); } @Override @@ -73,7 +79,7 @@ protected void parse(Parser parser) throws SBPBinaryException { wn = parser.getU16(); tow = parser.getU32(); ns_residual = parser.getS32(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -81,7 +87,7 @@ protected void build(Builder builder) { builder.putU16(wn); builder.putU32(tow); builder.putS32(ns_residual); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgGPSTimeDepA.java b/java/src/com/swiftnav/sbp/navigation/MsgGPSTimeDepA.java index ae78130b9..ef063f217 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgGPSTimeDepA.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgGPSTimeDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,52 +9,54 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_GPS_TIME_DEP_A (0x0100). + +/** SBP class for message MSG_GPS_TIME_DEP_A (0x0100). * - *

You can have MSG_GPS_TIME_DEP_A inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_GPS_TIME_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgGPSTimeDepA extends SBPMessage { public static final int TYPE = 0x0100; + /** GPS week number */ public int wn; - + /** GPS time of week rounded to the nearest millisecond */ public long tow; - - /** Nanosecond residual of millisecond-rounded TOW (ranges from -500000 to 500000) */ + + /** Nanosecond residual of millisecond-rounded TOW (ranges from -500000 to + * 500000) */ public int ns_residual; - + /** Status flags (reserved) */ public int flags; + - public MsgGPSTimeDepA(int sender) { - super(sender, TYPE); - } - - public MsgGPSTimeDepA() { - super(TYPE); - } - - public MsgGPSTimeDepA(SBPMessage msg) throws SBPBinaryException { + public MsgGPSTimeDepA (int sender) { super(sender, TYPE); } + public MsgGPSTimeDepA () { super(TYPE); } + public MsgGPSTimeDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgGPSTimeDepA, expected 256, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgGPSTimeDepA, expected 256, actual " + msg.type); } @Override @@ -62,7 +65,7 @@ protected void parse(Parser parser) throws SBPBinaryException { wn = parser.getU16(); tow = parser.getU32(); ns_residual = parser.getS32(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -70,7 +73,7 @@ protected void build(Builder builder) { builder.putU16(wn); builder.putU32(tow); builder.putS32(ns_residual); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgGPSTimeGnss.java b/java/src/com/swiftnav/sbp/navigation/MsgGPSTimeGnss.java index 556ca01cd..4240143c6 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgGPSTimeGnss.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgGPSTimeGnss.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,63 +9,67 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_GPS_TIME_GNSS (0x0104). + +/** SBP class for message MSG_GPS_TIME_GNSS (0x0104). * - *

You can have MSG_GPS_TIME_GNSS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_GPS_TIME_GNSS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the GPS time, representing the time since the GPS epoch began on midnight - * January 6, 1980 UTC. GPS time counts the weeks and seconds of the week. The weeks begin at the - * Saturday/Sunday transition. GPS week 0 began at the beginning of the GPS time scale. + * This message reports the GPS time, representing the time since the GPS + * epoch began on midnight January 6, 1980 UTC. GPS time counts the weeks and + * seconds of the week. The weeks begin at the Saturday/Sunday transition. GPS + * week 0 began at the beginning of the GPS time scale. * - *

Within each week number, the GPS time of the week is between between 0 and 604800 seconds - * (=60*60*24*7). Note that GPS time does not accumulate leap seconds, and as of now, has a small - * offset from UTC. In a message stream, this message precedes a set of other navigation messages - * referenced to the same time (but lacking the ns field) and indicates a more precise time of these - * messages. + * Within each week number, the GPS time of the week is between between 0 and + * 604800 seconds (=60*60*24*7). Note that GPS time does not accumulate leap + * seconds, and as of now, has a small offset from UTC. In a message stream, + * this message precedes a set of other navigation messages referenced to the + * same time (but lacking the ns field) and indicates a more precise time of + * these messages. * - *

The values in this message are from GNSS measurements only. To get values fused with inertial - * measurements use MSG_GPS_TIME. - */ + * The values in this message are from GNSS measurements only. To get values + * fused with inertial measurements use MSG_GPS_TIME. */ + public class MsgGPSTimeGnss extends SBPMessage { public static final int TYPE = 0x0104; + /** GPS week number */ public int wn; - + /** GPS time of week rounded to the nearest millisecond */ public long tow; - - /** Nanosecond residual of millisecond-rounded TOW (ranges from -500000 to 500000) */ + + /** Nanosecond residual of millisecond-rounded TOW (ranges from -500000 to + * 500000) */ public int ns_residual; - + /** Status flags (reserved) */ public int flags; + - public MsgGPSTimeGnss(int sender) { - super(sender, TYPE); - } - - public MsgGPSTimeGnss() { - super(TYPE); - } - - public MsgGPSTimeGnss(SBPMessage msg) throws SBPBinaryException { + public MsgGPSTimeGnss (int sender) { super(sender, TYPE); } + public MsgGPSTimeGnss () { super(TYPE); } + public MsgGPSTimeGnss (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgGPSTimeGnss, expected 260, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgGPSTimeGnss, expected 260, actual " + msg.type); } @Override @@ -73,7 +78,7 @@ protected void parse(Parser parser) throws SBPBinaryException { wn = parser.getU16(); tow = parser.getU32(); ns_residual = parser.getS32(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -81,7 +86,7 @@ protected void build(Builder builder) { builder.putU16(wn); builder.putU32(tow); builder.putS32(ns_residual); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPosECEF.java b/java/src/com/swiftnav/sbp/navigation/MsgPosECEF.java index 916194b0d..638e513d4 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgPosECEF.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgPosECEF.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,69 +9,72 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_POS_ECEF (0x0209). +/** SBP class for message MSG_POS_ECEF (0x0209). * - *

You can have MSG_POS_ECEF inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_POS_ECEF inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The position solution message reports absolute Earth Centered Earth Fixed (ECEF) coordinates - * and the status (single point vs pseudo-absolute RTK) of the position solution. If the rover - * receiver knows the surveyed position of the base station and has an RTK solution, this reports a - * pseudo-absolute position solution using the base station position and the rover's RTK baseline - * vector. The full GPS time is given by the preceding MSG_GPS_TIME with the matching time-of-week - * (tow). + * The position solution message reports absolute Earth Centered Earth Fixed + * (ECEF) coordinates and the status (single point vs pseudo-absolute RTK) of + * the position solution. If the rover receiver knows the surveyed position of + * the base station and has an RTK solution, this reports a pseudo-absolute + * position solution using the base station position and the rover's RTK + * baseline vector. The full GPS time is given by the preceding MSG_GPS_TIME + * with the matching time-of-week (tow). * - *

The values in this message are from GNSS measurements fused with inertial measurements. To get - * values from GNSS measurements only use MSG_POS_ECEF_GNSS. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. To get values from GNSS measurements only use + * MSG_POS_ECEF_GNSS. */ + public class MsgPosECEF extends SBPMessage { public static final int TYPE = 0x0209; + /** GPS Time of Week */ public long tow; - + /** ECEF X coordinate */ public double x; - + /** ECEF Y coordinate */ public double y; - + /** ECEF Z coordinate */ public double z; - + /** Position estimated standard deviation */ public int accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgPosECEF(int sender) { - super(sender, TYPE); - } - - public MsgPosECEF() { - super(TYPE); - } - - public MsgPosECEF(SBPMessage msg) throws SBPBinaryException { + public MsgPosECEF (int sender) { super(sender, TYPE); } + public MsgPosECEF () { super(TYPE); } + public MsgPosECEF (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPosECEF, expected 521, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPosECEF, expected 521, actual " + msg.type); } @Override @@ -82,7 +86,7 @@ protected void parse(Parser parser) throws SBPBinaryException { z = parser.getDouble(); accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -93,7 +97,7 @@ protected void build(Builder builder) { builder.putDouble(z); builder.putU16(accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPosECEFCov.java b/java/src/com/swiftnav/sbp/navigation/MsgPosECEFCov.java index 6a74fd653..d4c0cd42e 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgPosECEFCov.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgPosECEFCov.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,84 +9,88 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_POS_ECEF_COV (0x0214). +/** SBP class for message MSG_POS_ECEF_COV (0x0214). * - *

You can have MSG_POS_ECEF_COV inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_POS_ECEF_COV inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The position solution message reports absolute Earth Centered Earth Fixed (ECEF) coordinates - * and the status (single point vs pseudo-absolute RTK) of the position solution. The message also - * reports the upper triangular portion of the 3x3 covariance matrix. If the receiver knows the - * surveyed position of the base station and has an RTK solution, this reports a pseudo-absolute - * position solution using the base station position and the rover's RTK baseline vector. The full - * GPS time is given by the preceding MSG_GPS_TIME with the matching time-of-week (tow). + * The position solution message reports absolute Earth Centered Earth Fixed + * (ECEF) coordinates and the status (single point vs pseudo-absolute RTK) of + * the position solution. The message also reports the upper triangular + * portion of the 3x3 covariance matrix. If the receiver knows the surveyed + * position of the base station and has an RTK solution, this reports a + * pseudo-absolute position solution using the base station position and the + * rover's RTK baseline vector. The full GPS time is given by the preceding + * MSG_GPS_TIME with the matching time-of-week (tow). * - *

The values in this message are from GNSS measurements fused with inertial measurements. To get - * values from GNSS measurements only use MSG_POS_ECEF_COV_GNSS. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. To get values from GNSS measurements only use + * MSG_POS_ECEF_COV_GNSS. */ + public class MsgPosECEFCov extends SBPMessage { public static final int TYPE = 0x0214; + /** GPS Time of Week */ public long tow; - + /** ECEF X coordinate */ public double x; - + /** ECEF Y coordinate */ public double y; - + /** ECEF Z coordinate */ public double z; - + /** Estimated variance of x */ public float cov_x_x; - + /** Estimated covariance of x and y */ public float cov_x_y; - + /** Estimated covariance of x and z */ public float cov_x_z; - + /** Estimated variance of y */ public float cov_y_y; - + /** Estimated covariance of y and z */ public float cov_y_z; - + /** Estimated variance of z */ public float cov_z_z; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgPosECEFCov(int sender) { - super(sender, TYPE); - } - - public MsgPosECEFCov() { - super(TYPE); - } - - public MsgPosECEFCov(SBPMessage msg) throws SBPBinaryException { + public MsgPosECEFCov (int sender) { super(sender, TYPE); } + public MsgPosECEFCov () { super(TYPE); } + public MsgPosECEFCov (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPosECEFCov, expected 532, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPosECEFCov, expected 532, actual " + msg.type); } @Override @@ -102,7 +107,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cov_y_z = parser.getFloat(); cov_z_z = parser.getFloat(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -118,7 +123,7 @@ protected void build(Builder builder) { builder.putFloat(cov_y_z); builder.putFloat(cov_z_z); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPosECEFCovGnss.java b/java/src/com/swiftnav/sbp/navigation/MsgPosECEFCovGnss.java index 70ec5700f..e86ffbd6f 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgPosECEFCovGnss.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgPosECEFCovGnss.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,84 +9,87 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_POS_ECEF_COV_GNSS (0x0234). +/** SBP class for message MSG_POS_ECEF_COV_GNSS (0x0234). * - *

You can have MSG_POS_ECEF_COV_GNSS inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_POS_ECEF_COV_GNSS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The position solution message reports absolute Earth Centered Earth Fixed (ECEF) coordinates - * and the status (single point vs pseudo-absolute RTK) of the position solution. The message also - * reports the upper triangular portion of the 3x3 covariance matrix. If the receiver knows the - * surveyed position of the base station and has an RTK solution, this reports a pseudo-absolute - * position solution using the base station position and the rover's RTK baseline vector. The full - * GPS time is given by the preceding MSG_GPS_TIME_GNSS with the matching time-of-week (tow). + * The position solution message reports absolute Earth Centered Earth Fixed + * (ECEF) coordinates and the status (single point vs pseudo-absolute RTK) of + * the position solution. The message also reports the upper triangular + * portion of the 3x3 covariance matrix. If the receiver knows the surveyed + * position of the base station and has an RTK solution, this reports a + * pseudo-absolute position solution using the base station position and the + * rover's RTK baseline vector. The full GPS time is given by the preceding + * MSG_GPS_TIME_GNSS with the matching time-of-week (tow). * - *

The values in this message are from GNSS measurements only. To get values fused with inertial - * measurements use MSG_POS_ECEF_COV. - */ + * The values in this message are from GNSS measurements only. To get values + * fused with inertial measurements use MSG_POS_ECEF_COV. */ + public class MsgPosECEFCovGnss extends SBPMessage { public static final int TYPE = 0x0234; + /** GPS Time of Week */ public long tow; - + /** ECEF X coordinate */ public double x; - + /** ECEF Y coordinate */ public double y; - + /** ECEF Z coordinate */ public double z; - + /** Estimated variance of x */ public float cov_x_x; - + /** Estimated covariance of x and y */ public float cov_x_y; - + /** Estimated covariance of x and z */ public float cov_x_z; - + /** Estimated variance of y */ public float cov_y_y; - + /** Estimated covariance of y and z */ public float cov_y_z; - + /** Estimated variance of z */ public float cov_z_z; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgPosECEFCovGnss(int sender) { - super(sender, TYPE); - } - - public MsgPosECEFCovGnss() { - super(TYPE); - } - - public MsgPosECEFCovGnss(SBPMessage msg) throws SBPBinaryException { + public MsgPosECEFCovGnss (int sender) { super(sender, TYPE); } + public MsgPosECEFCovGnss () { super(TYPE); } + public MsgPosECEFCovGnss (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPosECEFCovGnss, expected 564, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPosECEFCovGnss, expected 564, actual " + msg.type); } @Override @@ -102,7 +106,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cov_y_z = parser.getFloat(); cov_z_z = parser.getFloat(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -118,7 +122,7 @@ protected void build(Builder builder) { builder.putFloat(cov_y_z); builder.putFloat(cov_z_z); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPosECEFDepA.java b/java/src/com/swiftnav/sbp/navigation/MsgPosECEFDepA.java index e895f5cfb..10c7e4126 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgPosECEFDepA.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgPosECEFDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_POS_ECEF_DEP_A (0x0200). +/** SBP class for message MSG_POS_ECEF_DEP_A (0x0200). * - *

You can have MSG_POS_ECEF_DEP_A inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_POS_ECEF_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgPosECEFDepA extends SBPMessage { public static final int TYPE = 0x0200; + /** GPS Time of Week */ public long tow; - + /** ECEF X coordinate */ public double x; - + /** ECEF Y coordinate */ public double y; - + /** ECEF Z coordinate */ public double z; - + /** Position accuracy estimate (not implemented). Defaults to 0. */ public int accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgPosECEFDepA(int sender) { - super(sender, TYPE); - } - - public MsgPosECEFDepA() { - super(TYPE); - } - - public MsgPosECEFDepA(SBPMessage msg) throws SBPBinaryException { + public MsgPosECEFDepA (int sender) { super(sender, TYPE); } + public MsgPosECEFDepA () { super(TYPE); } + public MsgPosECEFDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPosECEFDepA, expected 512, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPosECEFDepA, expected 512, actual " + msg.type); } @Override @@ -74,7 +76,7 @@ protected void parse(Parser parser) throws SBPBinaryException { z = parser.getDouble(); accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -85,7 +87,7 @@ protected void build(Builder builder) { builder.putDouble(z); builder.putU16(accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPosECEFGnss.java b/java/src/com/swiftnav/sbp/navigation/MsgPosECEFGnss.java index 6f82037fa..50d981eea 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgPosECEFGnss.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgPosECEFGnss.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,69 +9,71 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_POS_ECEF_GNSS (0x0229). +/** SBP class for message MSG_POS_ECEF_GNSS (0x0229). * - *

You can have MSG_POS_ECEF_GNSS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_POS_ECEF_GNSS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The position solution message reports absolute Earth Centered Earth Fixed (ECEF) coordinates - * and the status (single point vs pseudo-absolute RTK) of the position solution. If the rover - * receiver knows the surveyed position of the base station and has an RTK solution, this reports a - * pseudo-absolute position solution using the base station position and the rover's RTK baseline - * vector. The full GPS time is given by the preceding MSG_GPS_TIME_GNSS with the matching - * time-of-week (tow). + * The position solution message reports absolute Earth Centered Earth Fixed + * (ECEF) coordinates and the status (single point vs pseudo-absolute RTK) of + * the position solution. If the rover receiver knows the surveyed position of + * the base station and has an RTK solution, this reports a pseudo-absolute + * position solution using the base station position and the rover's RTK + * baseline vector. The full GPS time is given by the preceding + * MSG_GPS_TIME_GNSS with the matching time-of-week (tow). * - *

The values in this message are from GNSS measurements only. To get values fused with inertial - * measurements use MSG_POS_ECEF. - */ + * The values in this message are from GNSS measurements only. To get values + * fused with inertial measurements use MSG_POS_ECEF. */ + public class MsgPosECEFGnss extends SBPMessage { public static final int TYPE = 0x0229; + /** GPS Time of Week */ public long tow; - + /** ECEF X coordinate */ public double x; - + /** ECEF Y coordinate */ public double y; - + /** ECEF Z coordinate */ public double z; - + /** Position estimated standard deviation */ public int accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgPosECEFGnss(int sender) { - super(sender, TYPE); - } - - public MsgPosECEFGnss() { - super(TYPE); - } - - public MsgPosECEFGnss(SBPMessage msg) throws SBPBinaryException { + public MsgPosECEFGnss (int sender) { super(sender, TYPE); } + public MsgPosECEFGnss () { super(TYPE); } + public MsgPosECEFGnss (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPosECEFGnss, expected 553, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPosECEFGnss, expected 553, actual " + msg.type); } @Override @@ -82,7 +85,7 @@ protected void parse(Parser parser) throws SBPBinaryException { z = parser.getDouble(); accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -93,7 +96,7 @@ protected void build(Builder builder) { builder.putDouble(z); builder.putU16(accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPosLLH.java b/java/src/com/swiftnav/sbp/navigation/MsgPosLLH.java index c0f537780..272e08be2 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgPosLLH.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgPosLLH.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,71 +9,75 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_POS_LLH (0x020A). +/** SBP class for message MSG_POS_LLH (0x020A). * - *

You can have MSG_POS_LLH inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_POS_LLH inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This position solution message reports the absolute geodetic coordinates and the status - * (single point vs pseudo-absolute RTK) of the position solution. If the rover receiver knows the - * surveyed position of the base station and has an RTK solution, this reports a pseudo-absolute - * position solution using the base station position and the rover's RTK baseline vector. The full - * GPS time is given by the preceding MSG_GPS_TIME with the matching time-of-week (tow). + * This position solution message reports the absolute geodetic coordinates + * and the status (single point vs pseudo-absolute RTK) of the position + * solution. If the rover receiver knows the surveyed position of the base + * station and has an RTK solution, this reports a pseudo-absolute position + * solution using the base station position and the rover's RTK baseline + * vector. The full GPS time is given by the preceding MSG_GPS_TIME with the + * matching time-of-week (tow). * - *

The values in this message are from GNSS measurements fused with inertial measurements. To get - * values from GNSS measurements only use MSG_POS_LLH_GNSS. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. To get values from GNSS measurements only use + * MSG_POS_LLH_GNSS. */ + public class MsgPosLLH extends SBPMessage { public static final int TYPE = 0x020A; + /** GPS Time of Week */ public long tow; - + /** Latitude */ public double lat; - + /** Longitude */ public double lon; - + /** Height above WGS84 ellipsoid */ public double height; - + /** Horizontal position estimated standard deviation */ public int h_accuracy; - + /** Vertical position estimated standard deviation */ public int v_accuracy; - + /** Number of satellites used in solution. */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgPosLLH(int sender) { - super(sender, TYPE); - } - - public MsgPosLLH() { - super(TYPE); - } - - public MsgPosLLH(SBPMessage msg) throws SBPBinaryException { + public MsgPosLLH (int sender) { super(sender, TYPE); } + public MsgPosLLH () { super(TYPE); } + public MsgPosLLH (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPosLLH, expected 522, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPosLLH, expected 522, actual " + msg.type); } @Override @@ -85,7 +90,7 @@ protected void parse(Parser parser) throws SBPBinaryException { h_accuracy = parser.getU16(); v_accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -97,7 +102,7 @@ protected void build(Builder builder) { builder.putU16(h_accuracy); builder.putU16(v_accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPosLLHAcc.java b/java/src/com/swiftnav/sbp/navigation/MsgPosLLHAcc.java index 02690cacd..144fa62d9 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgPosLLHAcc.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgPosLLHAcc.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,98 +9,100 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_POS_LLH_ACC (0x0218). +/** SBP class for message MSG_POS_LLH_ACC (0x0218). * - *

You can have MSG_POS_LLH_ACC inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_POS_LLH_ACC inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This position solution message reports the absolute geodetic coordinates and the status - * (single point vs pseudo-absolute RTK) of the position solution as well as the estimated - * horizontal, vertical, cross-track and along-track errors. The position information and Fix Mode - * flags follow the MSG_POS_LLH message. Since the covariance matrix is computed in the local-level - * North, East, Down frame, the estimated error terms follow that convention. + * This position solution message reports the absolute geodetic coordinates + * and the status (single point vs pseudo-absolute RTK) of the position + * solution as well as the estimated horizontal, vertical, cross-track and + * along-track errors. The position information and Fix Mode flags follow + * the MSG_POS_LLH message. Since the covariance matrix is computed in the + * local-level North, East, Down frame, the estimated error terms follow that + * convention. * - *

The estimated errors are reported at a user-configurable confidence level. The user-configured - * percentile is encoded in the percentile field. + * The estimated errors are reported at a user-configurable confidence level. + * The user-configured percentile is encoded in the percentile field. * - *

The values in this message are from GNSS measurements fused with inertial measurements. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. */ + public class MsgPosLLHAcc extends SBPMessage { public static final int TYPE = 0x0218; + /** GPS Time of Week */ public long tow; - + /** Latitude */ public double lat; - + /** Longitude */ public double lon; - + /** Height above WGS84 ellipsoid */ public double height; - - /** - * Height above the geoid (i.e. height above mean sea level). See confidence_and_geoid for geoid - * model used. - */ + + /** Height above the geoid (i.e. height above mean sea level). See + * confidence_and_geoid for geoid model used. */ public double orthometric_height; - - /** Estimated horizontal error at the user-configured confidence level; zero implies invalid. */ + + /** Estimated horizontal error at the user-configured confidence level; + * zero implies invalid. */ public float h_accuracy; - - /** Estimated vertical error at the user-configured confidence level; zero implies invalid. */ + + /** Estimated vertical error at the user-configured confidence level; zero + * implies invalid. */ public float v_accuracy; - - /** - * Estimated cross-track error at the user-configured confidence level; zero implies invalid. - */ + + /** Estimated cross-track error at the user-configured confidence level; + * zero implies invalid. */ public float ct_accuracy; - - /** - * Estimated along-track error at the user-configured confidence level; zero implies invalid. - */ + + /** Estimated along-track error at the user-configured confidence level; + * zero implies invalid. */ public float at_accuracy; - - /** The estimated horizontal error ellipse at the user-configured confidence level. */ + + /** The estimated horizontal error ellipse at the user-configured + * confidence level. */ public EstimatedHorizontalErrorEllipse h_ellipse; - - /** - * The lower bits describe the configured confidence level for the estimated position error. The - * middle bits describe the geoid model used to calculate the orthometric height. - */ + + /** The lower bits describe the configured confidence level for the + * estimated position error. The middle bits describe the geoid model + * used to calculate the orthometric height. */ public int confidence_and_geoid; - + /** Number of satellites used in solution. */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgPosLLHAcc(int sender) { - super(sender, TYPE); - } - - public MsgPosLLHAcc() { - super(TYPE); - } - - public MsgPosLLHAcc(SBPMessage msg) throws SBPBinaryException { + public MsgPosLLHAcc (int sender) { super(sender, TYPE); } + public MsgPosLLHAcc () { super(TYPE); } + public MsgPosLLHAcc (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPosLLHAcc, expected 536, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPosLLHAcc, expected 536, actual " + msg.type); } @Override @@ -117,7 +120,7 @@ protected void parse(Parser parser) throws SBPBinaryException { h_ellipse = new EstimatedHorizontalErrorEllipse().parse(parser); confidence_and_geoid = parser.getU8(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -134,7 +137,7 @@ protected void build(Builder builder) { h_ellipse.build(builder); builder.putU8(confidence_and_geoid); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPosLLHCov.java b/java/src/com/swiftnav/sbp/navigation/MsgPosLLHCov.java index 8576cdef8..81c80ad87 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgPosLLHCov.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgPosLLHCov.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,84 +9,88 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_POS_LLH_COV (0x0211). +/** SBP class for message MSG_POS_LLH_COV (0x0211). * - *

You can have MSG_POS_LLH_COV inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_POS_LLH_COV inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This position solution message reports the absolute geodetic coordinates and the status - * (single point vs pseudo-absolute RTK) of the position solution as well as the upper triangle of - * the 3x3 covariance matrix. The position information and Fix Mode flags follow the MSG_POS_LLH - * message. Since the covariance matrix is computed in the local-level North, East, Down frame, the - * covariance terms follow that convention. Thus, covariances are reported against the "downward" - * measurement and care should be taken with the sign convention. + * This position solution message reports the absolute geodetic coordinates + * and the status (single point vs pseudo-absolute RTK) of the position + * solution as well as the upper triangle of the 3x3 covariance matrix. The + * position information and Fix Mode flags follow the MSG_POS_LLH message. + * Since the covariance matrix is computed in the local-level North, East, + * Down frame, the covariance terms follow that convention. Thus, covariances + * are reported against the "downward" measurement and care should be taken + * with the sign convention. * - *

The values in this message are from GNSS measurements fused with inertial measurements. To get - * values from GNSS measurements only use MSG_POS_LLH_COV_GNSS. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. To get values from GNSS measurements only use + * MSG_POS_LLH_COV_GNSS. */ + public class MsgPosLLHCov extends SBPMessage { public static final int TYPE = 0x0211; + /** GPS Time of Week */ public long tow; - + /** Latitude */ public double lat; - + /** Longitude */ public double lon; - + /** Height above WGS84 ellipsoid */ public double height; - + /** Estimated variance of northing */ public float cov_n_n; - + /** Covariance of northing and easting */ public float cov_n_e; - + /** Covariance of northing and downward measurement */ public float cov_n_d; - + /** Estimated variance of easting */ public float cov_e_e; - + /** Covariance of easting and downward measurement */ public float cov_e_d; - + /** Estimated variance of downward measurement */ public float cov_d_d; - + /** Number of satellites used in solution. */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgPosLLHCov(int sender) { - super(sender, TYPE); - } - - public MsgPosLLHCov() { - super(TYPE); - } - - public MsgPosLLHCov(SBPMessage msg) throws SBPBinaryException { + public MsgPosLLHCov (int sender) { super(sender, TYPE); } + public MsgPosLLHCov () { super(TYPE); } + public MsgPosLLHCov (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPosLLHCov, expected 529, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPosLLHCov, expected 529, actual " + msg.type); } @Override @@ -102,7 +107,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cov_e_d = parser.getFloat(); cov_d_d = parser.getFloat(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -118,7 +123,7 @@ protected void build(Builder builder) { builder.putFloat(cov_e_d); builder.putFloat(cov_d_d); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPosLLHCovGnss.java b/java/src/com/swiftnav/sbp/navigation/MsgPosLLHCovGnss.java index c91dfbf05..8d58beea6 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgPosLLHCovGnss.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgPosLLHCovGnss.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,84 +9,87 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_POS_LLH_COV_GNSS (0x0231). +/** SBP class for message MSG_POS_LLH_COV_GNSS (0x0231). * - *

You can have MSG_POS_LLH_COV_GNSS inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_POS_LLH_COV_GNSS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This position solution message reports the absolute geodetic coordinates and the status - * (single point vs pseudo-absolute RTK) of the position solution as well as the upper triangle of - * the 3x3 covariance matrix. The position information and Fix Mode flags should follow the - * MSG_POS_LLH_GNSS message. Since the covariance matrix is computed in the local-level North, East, - * Down frame, the covariance terms follow with that convention. Thus, covariances are reported - * against the "downward" measurement and care should be taken with the sign convention. + * This position solution message reports the absolute geodetic coordinates + * and the status (single point vs pseudo-absolute RTK) of the position + * solution as well as the upper triangle of the 3x3 covariance matrix. The + * position information and Fix Mode flags should follow the MSG_POS_LLH_GNSS + * message. Since the covariance matrix is computed in the local-level North, + * East, Down frame, the covariance terms follow with that convention. Thus, + * covariances are reported against the "downward" measurement and care should + * be taken with the sign convention. * - *

The values in this message are from GNSS measurements only. To get values fused with inertial - * measurements use MSG_POS_LLH_COV. - */ + * The values in this message are from GNSS measurements only. To get values + * fused with inertial measurements use MSG_POS_LLH_COV. */ + public class MsgPosLLHCovGnss extends SBPMessage { public static final int TYPE = 0x0231; + /** GPS Time of Week */ public long tow; - + /** Latitude */ public double lat; - + /** Longitude */ public double lon; - + /** Height above WGS84 ellipsoid */ public double height; - + /** Estimated variance of northing */ public float cov_n_n; - + /** Covariance of northing and easting */ public float cov_n_e; - + /** Covariance of northing and downward measurement */ public float cov_n_d; - + /** Estimated variance of easting */ public float cov_e_e; - + /** Covariance of easting and downward measurement */ public float cov_e_d; - + /** Estimated variance of downward measurement */ public float cov_d_d; - + /** Number of satellites used in solution. */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgPosLLHCovGnss(int sender) { - super(sender, TYPE); - } - - public MsgPosLLHCovGnss() { - super(TYPE); - } - - public MsgPosLLHCovGnss(SBPMessage msg) throws SBPBinaryException { + public MsgPosLLHCovGnss (int sender) { super(sender, TYPE); } + public MsgPosLLHCovGnss () { super(TYPE); } + public MsgPosLLHCovGnss (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPosLLHCovGnss, expected 561, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPosLLHCovGnss, expected 561, actual " + msg.type); } @Override @@ -102,7 +106,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cov_e_d = parser.getFloat(); cov_d_d = parser.getFloat(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -118,7 +122,7 @@ protected void build(Builder builder) { builder.putFloat(cov_e_d); builder.putFloat(cov_d_d); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPosLLHDepA.java b/java/src/com/swiftnav/sbp/navigation/MsgPosLLHDepA.java index 182148027..3c1cf3b52 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgPosLLHDepA.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgPosLLHDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,64 +9,66 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_POS_LLH_DEP_A (0x0201). +/** SBP class for message MSG_POS_LLH_DEP_A (0x0201). * - *

You can have MSG_POS_LLH_DEP_A inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_POS_LLH_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgPosLLHDepA extends SBPMessage { public static final int TYPE = 0x0201; + /** GPS Time of Week */ public long tow; - + /** Latitude */ public double lat; - + /** Longitude */ public double lon; - + /** Height */ public double height; - - /** Horizontal position accuracy estimate (not implemented). Defaults to 0. */ + + /** Horizontal position accuracy estimate (not implemented). Defaults to + * 0. */ public int h_accuracy; - + /** Vertical position accuracy estimate (not implemented). Defaults to 0. */ public int v_accuracy; - + /** Number of satellites used in solution. */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgPosLLHDepA(int sender) { - super(sender, TYPE); - } - - public MsgPosLLHDepA() { - super(TYPE); - } - - public MsgPosLLHDepA(SBPMessage msg) throws SBPBinaryException { + public MsgPosLLHDepA (int sender) { super(sender, TYPE); } + public MsgPosLLHDepA () { super(TYPE); } + public MsgPosLLHDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPosLLHDepA, expected 513, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPosLLHDepA, expected 513, actual " + msg.type); } @Override @@ -78,7 +81,7 @@ protected void parse(Parser parser) throws SBPBinaryException { h_accuracy = parser.getU16(); v_accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -90,7 +93,7 @@ protected void build(Builder builder) { builder.putU16(h_accuracy); builder.putU16(v_accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPosLLHGnss.java b/java/src/com/swiftnav/sbp/navigation/MsgPosLLHGnss.java index 84da61dbf..40baecb38 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgPosLLHGnss.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgPosLLHGnss.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,71 +9,74 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_POS_LLH_GNSS (0x022A). +/** SBP class for message MSG_POS_LLH_GNSS (0x022A). * - *

You can have MSG_POS_LLH_GNSS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_POS_LLH_GNSS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This position solution message reports the absolute geodetic coordinates and the status - * (single point vs pseudo-absolute RTK) of the position solution. If the rover receiver knows the - * surveyed position of the base station and has an RTK solution, this reports a pseudo-absolute - * position solution using the base station position and the rover's RTK baseline vector. The full - * GPS time is given by the preceding MSG_GPS_TIME_GNSS with the matching time-of-week (tow). + * This position solution message reports the absolute geodetic coordinates + * and the status (single point vs pseudo-absolute RTK) of the position + * solution. If the rover receiver knows the surveyed position of the base + * station and has an RTK solution, this reports a pseudo-absolute position + * solution using the base station position and the rover's RTK baseline + * vector. The full GPS time is given by the preceding MSG_GPS_TIME_GNSS with + * the matching time-of-week (tow). * - *

The values in this message are from GNSS measurements only. To get values fused with inertial - * measurements use MSG_POS_LLH. - */ + * The values in this message are from GNSS measurements only. To get values + * fused with inertial measurements use MSG_POS_LLH. */ + public class MsgPosLLHGnss extends SBPMessage { public static final int TYPE = 0x022A; + /** GPS Time of Week */ public long tow; - + /** Latitude */ public double lat; - + /** Longitude */ public double lon; - + /** Height above WGS84 ellipsoid */ public double height; - + /** Horizontal position estimated standard deviation */ public int h_accuracy; - + /** Vertical position estimated standard deviation */ public int v_accuracy; - + /** Number of satellites used in solution. */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgPosLLHGnss(int sender) { - super(sender, TYPE); - } - - public MsgPosLLHGnss() { - super(TYPE); - } - - public MsgPosLLHGnss(SBPMessage msg) throws SBPBinaryException { + public MsgPosLLHGnss (int sender) { super(sender, TYPE); } + public MsgPosLLHGnss () { super(TYPE); } + public MsgPosLLHGnss (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPosLLHGnss, expected 554, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPosLLHGnss, expected 554, actual " + msg.type); } @Override @@ -85,7 +89,7 @@ protected void parse(Parser parser) throws SBPBinaryException { h_accuracy = parser.getU16(); v_accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -97,7 +101,7 @@ protected void build(Builder builder) { builder.putU16(h_accuracy); builder.putU16(v_accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgPoseRelative.java b/java/src/com/swiftnav/sbp/navigation/MsgPoseRelative.java index 983cf2107..d93aae236 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgPoseRelative.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgPoseRelative.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,120 +9,117 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_POSE_RELATIVE (0x0245). +/** SBP class for message MSG_POSE_RELATIVE (0x0245). * - *

You can have MSG_POSE_RELATIVE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_POSE_RELATIVE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This solution message reports the relative pose of a sensor between two time instances. The - * relative pose comprises of a rotation and a translation which relates the sensor (e.g. camera) - * frame at a given time (first keyframe) to the sensor frame at another time (second keyframe). The - * relative translations is a 3x1 vector described in the first keyframe. Relative rotation is - * described by a quaternion from second keyframe to the first keyframe. - */ + * This solution message reports the relative pose of a sensor between two + * time instances. The relative pose comprises of a rotation and a translation + * which relates the sensor (e.g. camera) frame at a given time (first + * keyframe) to the sensor frame at another time (second keyframe). The + * relative translations is a 3x1 vector described in the first keyframe. + * Relative rotation is described by a quaternion from second keyframe to the + * first keyframe. */ + public class MsgPoseRelative extends SBPMessage { public static final int TYPE = 0x0245; + /** GPS Time of Week */ public long tow; - + /** ID of the sensor producing this message */ public int sensor_id; - + /** Timestamp of first keyframe */ public long timestamp_1; - + /** Timestamp of second keyframe */ public long timestamp_2; - + /** Relative translation [x,y,z] described in first keyframe */ public int[] trans; - - /** Real component of quaternion to describe relative rotation (second to first keyframe) */ + + /** Real component of quaternion to describe relative rotation (second to + * first keyframe) */ public int w; - - /** - * 1st imaginary component of quaternion to describe relative rotation (second to first - * keyframe) - */ + + /** 1st imaginary component of quaternion to describe relative rotation + * (second to first keyframe) */ public int x; - - /** - * 2nd imaginary component of quaternion to describe relative rotation (second to first - * keyframe) - */ + + /** 2nd imaginary component of quaternion to describe relative rotation + * (second to first keyframe) */ public int y; - - /** - * 3rd imaginary component of quaternion to describe relative rotation (second to first - * keyframe) - */ + + /** 3rd imaginary component of quaternion to describe relative rotation + * (second to first keyframe) */ public int z; - + /** Estimated variance of x (relative translation) */ public float cov_r_x_x; - + /** Covariance of x and y (relative translation) */ public float cov_r_x_y; - + /** Covariance of x and z (relative translation) */ public float cov_r_x_z; - + /** Estimated variance of y (relative translation) */ public float cov_r_y_y; - + /** Covariance of y and z (relative translation) */ public float cov_r_y_z; - + /** Estimated variance of z (relative translation) */ public float cov_r_z_z; - + /** Estimated variance of x (relative rotation) */ public float cov_c_x_x; - + /** Covariance of x and y (relative rotation) */ public float cov_c_x_y; - + /** Covariance of x and z (relative rotation) */ public float cov_c_x_z; - + /** Estimated variance of y (relative rotation) */ public float cov_c_y_y; - + /** Covariance of y and z (relative rotation) */ public float cov_c_y_z; - + /** Estimated variance of z (relative rotation) */ public float cov_c_z_z; - + /** Status flags of relative translation and rotation */ public int flags; + - public MsgPoseRelative(int sender) { - super(sender, TYPE); - } - - public MsgPoseRelative() { - super(TYPE); - } - - public MsgPoseRelative(SBPMessage msg) throws SBPBinaryException { + public MsgPoseRelative (int sender) { super(sender, TYPE); } + public MsgPoseRelative () { super(TYPE); } + public MsgPoseRelative (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPoseRelative, expected 581, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPoseRelative, expected 581, actual " + msg.type); } @Override @@ -148,7 +146,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cov_c_y_y = parser.getFloat(); cov_c_y_z = parser.getFloat(); cov_c_z_z = parser.getFloat(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -174,7 +172,7 @@ protected void build(Builder builder) { builder.putFloat(cov_c_y_y); builder.putFloat(cov_c_y_z); builder.putFloat(cov_c_z_z); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgProtectionLevel.java b/java/src/com/swiftnav/sbp/navigation/MsgProtectionLevel.java index 8f07ff8c8..e3fe8c04e 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgProtectionLevel.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgProtectionLevel.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,110 +9,108 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_PROTECTION_LEVEL (0x0217). + +/** SBP class for message MSG_PROTECTION_LEVEL (0x0217). * - *

You can have MSG_PROTECTION_LEVEL inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_PROTECTION_LEVEL inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the protection levels associated to the given state estimate. The full - * GPS time is given by the preceding MSG_GPS_TIME with the matching time-of-week (tow). - */ + * This message reports the protection levels associated to the given state + * estimate. The full GPS time is given by the preceding MSG_GPS_TIME with the + * matching time-of-week (tow). */ + public class MsgProtectionLevel extends SBPMessage { public static final int TYPE = 0x0217; + /** GPS Time of Week */ public long tow; - + /** GPS week number */ public int wn; - + /** Horizontal protection level */ public int hpl; - + /** Vertical protection level */ public int vpl; - + /** Along-track position error protection level */ public int atpl; - + /** Cross-track position error protection level */ public int ctpl; - - /** - * Protection level for the error vector between estimated and true along/cross track velocity - * vector - */ + + /** Protection level for the error vector between estimated and true + * along/cross track velocity vector */ public int hvpl; - - /** - * Protection level for the velocity in vehicle upright direction (different from vertical - * direction if on a slope) - */ + + /** Protection level for the velocity in vehicle upright direction + * (different from vertical direction if on a slope) */ public int vvpl; - + /** Heading orientation protection level */ public int hopl; - + /** Pitch orientation protection level */ public int popl; - + /** Roll orientation protection level */ public int ropl; - + /** Latitude */ public double lat; - + /** Longitude */ public double lon; - + /** Height */ public double height; - + /** Velocity in vehicle x direction */ public int v_x; - + /** Velocity in vehicle y direction */ public int v_y; - + /** Velocity in vehicle z direction */ public int v_z; - + /** Roll angle */ public int roll; - + /** Pitch angle */ public int pitch; - + /** Heading angle */ public int heading; - + /** Status flags */ public long flags; + - public MsgProtectionLevel(int sender) { - super(sender, TYPE); - } - - public MsgProtectionLevel() { - super(TYPE); - } - - public MsgProtectionLevel(SBPMessage msg) throws SBPBinaryException { + public MsgProtectionLevel (int sender) { super(sender, TYPE); } + public MsgProtectionLevel () { super(TYPE); } + public MsgProtectionLevel (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgProtectionLevel, expected 535, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgProtectionLevel, expected 535, actual " + msg.type); } @Override @@ -137,7 +136,7 @@ protected void parse(Parser parser) throws SBPBinaryException { roll = parser.getS32(); pitch = parser.getS32(); heading = parser.getS32(); - flags = parser.getU32(); + flags = parser.getU32(); } @Override @@ -162,7 +161,7 @@ protected void build(Builder builder) { builder.putS32(roll); builder.putS32(pitch); builder.putS32(heading); - builder.putU32(flags); + builder.putU32(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgProtectionLevelDepA.java b/java/src/com/swiftnav/sbp/navigation/MsgProtectionLevelDepA.java index 9f28db67b..a292ccf1c 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgProtectionLevelDepA.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgProtectionLevelDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_PROTECTION_LEVEL_DEP_A (0x0216). +/** SBP class for message MSG_PROTECTION_LEVEL_DEP_A (0x0216). * - *

You can have MSG_PROTECTION_LEVEL_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_PROTECTION_LEVEL_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgProtectionLevelDepA extends SBPMessage { public static final int TYPE = 0x0216; + /** GPS Time of Week */ public long tow; - + /** Vertical protection level */ public int vpl; - + /** Horizontal protection level */ public int hpl; - + /** Latitude */ public double lat; - + /** Longitude */ public double lon; - + /** Height */ public double height; - + /** Status flags */ public int flags; + - public MsgProtectionLevelDepA(int sender) { - super(sender, TYPE); - } - - public MsgProtectionLevelDepA() { - super(TYPE); - } - - public MsgProtectionLevelDepA(SBPMessage msg) throws SBPBinaryException { + public MsgProtectionLevelDepA (int sender) { super(sender, TYPE); } + public MsgProtectionLevelDepA () { super(TYPE); } + public MsgProtectionLevelDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgProtectionLevelDepA, expected 534, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgProtectionLevelDepA, expected 534, actual " + msg.type); } @Override @@ -74,7 +76,7 @@ protected void parse(Parser parser) throws SBPBinaryException { lat = parser.getDouble(); lon = parser.getDouble(); height = parser.getDouble(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -85,7 +87,7 @@ protected void build(Builder builder) { builder.putDouble(lat); builder.putDouble(lon); builder.putDouble(height); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgReferenceFrameParam.java b/java/src/com/swiftnav/sbp/navigation/MsgReferenceFrameParam.java index f5e9f3753..b574432a9 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgReferenceFrameParam.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgReferenceFrameParam.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,95 +9,95 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgReferenceFrameParam extends SBPMessage { public static final int TYPE = 0x0244; + /** SSR IOD parameter. */ public int ssr_iod; - + /** Name of source coordinate-system. */ public String sn; - + /** Name of target coordinate-system. */ public String tn; - + /** System Identification Number. */ public int sin; - + /** Utilized Transformation Message. */ public int utn; - - /** - * Reference Epoch t0 for transformation parameter set given as Modified Julian Day (MJD) Number - * minus 44244 days. - */ + + /** Reference Epoch t0 for transformation parameter set given as Modified + * Julian Day (MJD) Number minus 44244 days. */ public int re_t0; - + /** Translation in X for Reference Epoch t0. */ public int delta_X0; - + /** Translation in Y for Reference Epoch t0. */ public int delta_Y0; - + /** Translation in Z for Reference Epoch t0. */ public int delta_Z0; - + /** Rotation around the X-axis for Reference Epoch t0. */ public int theta_01; - + /** Rotation around the Y-axis for Reference Epoch t0. */ public int theta_02; - + /** Rotation around the Z-axis for Reference Epoch t0. */ public int theta_03; - + /** Scale correction for Reference Epoch t0. */ public int scale; - + /** Rate of change of translation in X. */ public int dot_delta_X0; - + /** Rate of change of translation in Y. */ public int dot_delta_Y0; - + /** Rate of change of translation in Z. */ public int dot_delta_Z0; - + /** Rate of change of rotation around the X-axis. */ public int dot_theta_01; - + /** Rate of change of rotation around the Y-axis. */ public int dot_theta_02; - + /** Rate of change of rotation around the Z-axis. */ public int dot_theta_03; - + /** Rate of change of scale correction. */ public int dot_scale; + - public MsgReferenceFrameParam(int sender) { - super(sender, TYPE); - } - - public MsgReferenceFrameParam() { - super(TYPE); - } - - public MsgReferenceFrameParam(SBPMessage msg) throws SBPBinaryException { + public MsgReferenceFrameParam (int sender) { super(sender, TYPE); } + public MsgReferenceFrameParam () { super(TYPE); } + public MsgReferenceFrameParam (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgReferenceFrameParam, expected 580, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgReferenceFrameParam, expected 580, actual " + msg.type); } @Override @@ -121,7 +122,7 @@ protected void parse(Parser parser) throws SBPBinaryException { dot_theta_01 = parser.getS32(); dot_theta_02 = parser.getS32(); dot_theta_03 = parser.getS32(); - dot_scale = parser.getS16(); + dot_scale = parser.getS16(); } @Override @@ -145,7 +146,7 @@ protected void build(Builder builder) { builder.putS32(dot_theta_01); builder.putS32(dot_theta_02); builder.putS32(dot_theta_03); - builder.putS16(dot_scale); + builder.putS16(dot_scale); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgUtcLeapSecond.java b/java/src/com/swiftnav/sbp/navigation/MsgUtcLeapSecond.java index da7008d9c..83c51b02f 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgUtcLeapSecond.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgUtcLeapSecond.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,68 +9,69 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_UTC_LEAP_SECOND (0x023A). +/** SBP class for message MSG_UTC_LEAP_SECOND (0x023A). * - *

You can have MSG_UTC_LEAP_SECOND inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_UTC_LEAP_SECOND inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

UTC-GPST leap seconds before and after the most recent (past, or future, for announced - * insertions) UTC leap second insertion. - */ + * UTC-GPST leap seconds before and after the most recent (past, or future, + * for announced insertions) UTC leap second insertion. */ + public class MsgUtcLeapSecond extends SBPMessage { public static final int TYPE = 0x023A; + /** Reserved. */ public int reserved_0; - + /** Reserved. */ public int reserved_1; - + /** Reserved. */ public int reserved_2; - + /** Leap second count before insertion. */ public int count_before; - + /** Reserved. */ public int reserved_3; - + /** Reserved. */ public int reserved_4; - + /** Leap second reference GPS week number. */ public int ref_wn; - + /** Leap second reference day number. */ public int ref_dn; - + /** Leap second count after insertion. */ public int count_after; + - public MsgUtcLeapSecond(int sender) { - super(sender, TYPE); - } - - public MsgUtcLeapSecond() { - super(TYPE); - } - - public MsgUtcLeapSecond(SBPMessage msg) throws SBPBinaryException { + public MsgUtcLeapSecond (int sender) { super(sender, TYPE); } + public MsgUtcLeapSecond () { super(TYPE); } + public MsgUtcLeapSecond (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgUtcLeapSecond, expected 570, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgUtcLeapSecond, expected 570, actual " + msg.type); } @Override @@ -83,7 +85,7 @@ protected void parse(Parser parser) throws SBPBinaryException { reserved_4 = parser.getU16(); ref_wn = parser.getU16(); ref_dn = parser.getU8(); - count_after = parser.getS8(); + count_after = parser.getS8(); } @Override @@ -96,7 +98,7 @@ protected void build(Builder builder) { builder.putU16(reserved_4); builder.putU16(ref_wn); builder.putU8(ref_dn); - builder.putS8(count_after); + builder.putS8(count_after); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgUtcTime.java b/java/src/com/swiftnav/sbp/navigation/MsgUtcTime.java index f9043655e..afcc201bd 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgUtcTime.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgUtcTime.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,71 +9,74 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_UTC_TIME (0x0103). +/** SBP class for message MSG_UTC_TIME (0x0103). * - *

You can have MSG_UTC_TIME inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_UTC_TIME inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the Universal Coordinated Time (UTC). Note the flags which indicate the - * source of the UTC offset value and source of the time fix. + * This message reports the Universal Coordinated Time (UTC). Note the flags + * which indicate the source of the UTC offset value and source of the time + * fix. * - *

The values in this message are from GNSS measurements fused with inertial measurements. To get - * values from GNSS measurements only use MSG_UTC_TIME_GNSS. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. To get values from GNSS measurements only use + * MSG_UTC_TIME_GNSS. */ + public class MsgUtcTime extends SBPMessage { public static final int TYPE = 0x0103; + /** Indicates source and time validity */ public int flags; - + /** GPS time of week rounded to the nearest millisecond */ public long tow; - + /** Year */ public int year; - + /** Month (range 1 .. 12) */ public int month; - + /** days in the month (range 1-31) */ public int day; - + /** hours of day (range 0-23) */ public int hours; - + /** minutes of hour (range 0-59) */ public int minutes; - + /** seconds of minute (range 0-60) rounded down */ public int seconds; - + /** nanoseconds of second (range 0-999999999) */ public long ns; + - public MsgUtcTime(int sender) { - super(sender, TYPE); - } - - public MsgUtcTime() { - super(TYPE); - } - - public MsgUtcTime(SBPMessage msg) throws SBPBinaryException { + public MsgUtcTime (int sender) { super(sender, TYPE); } + public MsgUtcTime () { super(TYPE); } + public MsgUtcTime (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgUtcTime, expected 259, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgUtcTime, expected 259, actual " + msg.type); } @Override @@ -86,7 +90,7 @@ protected void parse(Parser parser) throws SBPBinaryException { hours = parser.getU8(); minutes = parser.getU8(); seconds = parser.getU8(); - ns = parser.getU32(); + ns = parser.getU32(); } @Override @@ -99,7 +103,7 @@ protected void build(Builder builder) { builder.putU8(hours); builder.putU8(minutes); builder.putU8(seconds); - builder.putU32(ns); + builder.putU32(ns); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgUtcTimeGnss.java b/java/src/com/swiftnav/sbp/navigation/MsgUtcTimeGnss.java index a0dcbe38b..27945e1a9 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgUtcTimeGnss.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgUtcTimeGnss.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,71 +9,73 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_UTC_TIME_GNSS (0x0105). +/** SBP class for message MSG_UTC_TIME_GNSS (0x0105). * - *

You can have MSG_UTC_TIME_GNSS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_UTC_TIME_GNSS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the Universal Coordinated Time (UTC). Note the flags which indicate the - * source of the UTC offset value and source of the time fix. + * This message reports the Universal Coordinated Time (UTC). Note the flags + * which indicate the source of the UTC offset value and source of the time + * fix. * - *

The values in this message are from GNSS measurements only. To get values fused with inertial - * measurements use MSG_UTC_TIME. - */ + * The values in this message are from GNSS measurements only. To get values + * fused with inertial measurements use MSG_UTC_TIME. */ + public class MsgUtcTimeGnss extends SBPMessage { public static final int TYPE = 0x0105; + /** Indicates source and time validity */ public int flags; - + /** GPS time of week rounded to the nearest millisecond */ public long tow; - + /** Year */ public int year; - + /** Month (range 1 .. 12) */ public int month; - + /** days in the month (range 1-31) */ public int day; - + /** hours of day (range 0-23) */ public int hours; - + /** minutes of hour (range 0-59) */ public int minutes; - + /** seconds of minute (range 0-60) rounded down */ public int seconds; - + /** nanoseconds of second (range 0-999999999) */ public long ns; + - public MsgUtcTimeGnss(int sender) { - super(sender, TYPE); - } - - public MsgUtcTimeGnss() { - super(TYPE); - } - - public MsgUtcTimeGnss(SBPMessage msg) throws SBPBinaryException { + public MsgUtcTimeGnss (int sender) { super(sender, TYPE); } + public MsgUtcTimeGnss () { super(TYPE); } + public MsgUtcTimeGnss (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgUtcTimeGnss, expected 261, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgUtcTimeGnss, expected 261, actual " + msg.type); } @Override @@ -86,7 +89,7 @@ protected void parse(Parser parser) throws SBPBinaryException { hours = parser.getU8(); minutes = parser.getU8(); seconds = parser.getU8(); - ns = parser.getU32(); + ns = parser.getU32(); } @Override @@ -99,7 +102,7 @@ protected void build(Builder builder) { builder.putU8(hours); builder.putU8(minutes); builder.putU8(seconds); - builder.putU32(ns); + builder.putU32(ns); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgVelBody.java b/java/src/com/swiftnav/sbp/navigation/MsgVelBody.java index 3fee889d0..ae528c888 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgVelBody.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgVelBody.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,84 +9,88 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_VEL_BODY (0x0213). +/** SBP class for message MSG_VEL_BODY (0x0213). * - *

You can have MSG_VEL_BODY inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_VEL_BODY inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the velocity in the Vehicle Body Frame. By convention, the x-axis should - * point out the nose of the vehicle and represent the forward direction, while as the y-axis should - * point out the right hand side of the vehicle. Since this is a right handed system, z should point - * out the bottom of the vehicle. The orientation and origin of the Vehicle Body Frame are specified - * via the device settings. The full GPS time is given by the preceding MSG_GPS_TIME with the - * matching time-of-week (tow). This message is only produced by inertial versions of Swift products - * and is not available from Piksi Multi or Duro. + * This message reports the velocity in the Vehicle Body Frame. By convention, + * the x-axis should point out the nose of the vehicle and represent the + * forward direction, while as the y-axis should point out the right hand side + * of the vehicle. Since this is a right handed system, z should point out the + * bottom of the vehicle. The orientation and origin of the Vehicle Body Frame + * are specified via the device settings. The full GPS time is given by the + * preceding MSG_GPS_TIME with the matching time-of-week (tow). This message + * is only produced by inertial versions of Swift products and is not + * available from Piksi Multi or Duro. * - *

The values in this message are from GNSS measurements fused with inertial measurements. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. */ + public class MsgVelBody extends SBPMessage { public static final int TYPE = 0x0213; + /** GPS Time of Week */ public long tow; - + /** Velocity in x direction */ public int x; - + /** Velocity in y direction */ public int y; - + /** Velocity in z direction */ public int z; - + /** Estimated variance of x */ public float cov_x_x; - + /** Covariance of x and y */ public float cov_x_y; - + /** Covariance of x and z */ public float cov_x_z; - + /** Estimated variance of y */ public float cov_y_y; - + /** Covariance of y and z */ public float cov_y_z; - + /** Estimated variance of z */ public float cov_z_z; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgVelBody(int sender) { - super(sender, TYPE); - } - - public MsgVelBody() { - super(TYPE); - } - - public MsgVelBody(SBPMessage msg) throws SBPBinaryException { + public MsgVelBody (int sender) { super(sender, TYPE); } + public MsgVelBody () { super(TYPE); } + public MsgVelBody (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgVelBody, expected 531, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgVelBody, expected 531, actual " + msg.type); } @Override @@ -102,7 +107,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cov_y_z = parser.getFloat(); cov_z_z = parser.getFloat(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -118,7 +123,7 @@ protected void build(Builder builder) { builder.putFloat(cov_y_z); builder.putFloat(cov_z_z); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgVelCog.java b/java/src/com/swiftnav/sbp/navigation/MsgVelCog.java index f02669f26..449896b87 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgVelCog.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgVelCog.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,73 +9,78 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_VEL_COG (0x021C). +/** SBP class for message MSG_VEL_COG (0x021C). * - *

You can have MSG_VEL_COG inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_VEL_COG inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the receiver course over ground (COG) and speed over ground (SOG) based - * on the horizontal (N-E) components of the NED velocity vector. It also includes the vertical - * velocity coordinate. A flag is provided to indicate whether the COG value has been frozen. When - * the flag is set to true, the COG field is set to its last valid value until the system exceeds a - * minimum velocity threshold. No other fields are affected by this flag. The NED coordinate system - * is defined as the local WGS84 tangent plane centered at the current position. The full GPS time - * is given by the preceding MSG_GPS_TIME with the matching time-of-week (tow). Note: course over - * ground represents the receiver's direction of travel, but not necessarily the device heading. + * This message reports the receiver course over ground (COG) and speed over + * ground (SOG) based on the horizontal (N-E) components of the NED velocity + * vector. It also includes the vertical velocity coordinate. A flag is + * provided to indicate whether the COG value has been frozen. When the flag + * is set to true, the COG field is set to its last valid value until the + * system exceeds a minimum velocity threshold. No other fields are affected + * by this flag. The NED coordinate system is defined as the local WGS84 + * tangent plane centered at the current position. The full GPS time is given + * by the preceding MSG_GPS_TIME with the matching time-of-week (tow). Note: + * course over ground represents the receiver's direction of travel, but not + * necessarily the device heading. * - *

The values in this message are from GNSS measurements fused with inertial measurements. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. */ + public class MsgVelCog extends SBPMessage { public static final int TYPE = 0x021C; + /** GPS Time of Week */ public long tow; - + /** Course over ground relative to north direction */ public long cog; - + /** Speed over ground (based on horizontal velocity) */ public long sog; - + /** Vertical velocity component (positive up) */ public int v_up; - + /** Course over ground estimated standard deviation */ public long cog_accuracy; - + /** Speed over ground estimated standard deviation */ public long sog_accuracy; - + /** Vertical velocity estimated standard deviation */ public long v_up_accuracy; - + /** Status flags */ public int flags; + - public MsgVelCog(int sender) { - super(sender, TYPE); - } - - public MsgVelCog() { - super(TYPE); - } - - public MsgVelCog(SBPMessage msg) throws SBPBinaryException { + public MsgVelCog (int sender) { super(sender, TYPE); } + public MsgVelCog () { super(TYPE); } + public MsgVelCog (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgVelCog, expected 540, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgVelCog, expected 540, actual " + msg.type); } @Override @@ -87,7 +93,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cog_accuracy = parser.getU32(); sog_accuracy = parser.getU32(); v_up_accuracy = parser.getU32(); - flags = parser.getU16(); + flags = parser.getU16(); } @Override @@ -99,7 +105,7 @@ protected void build(Builder builder) { builder.putU32(cog_accuracy); builder.putU32(sog_accuracy); builder.putU32(v_up_accuracy); - builder.putU16(flags); + builder.putU16(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgVelECEF.java b/java/src/com/swiftnav/sbp/navigation/MsgVelECEF.java index ca256db3e..0af3b9752 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgVelECEF.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgVelECEF.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,65 +9,68 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_VEL_ECEF (0x020D). +/** SBP class for message MSG_VEL_ECEF (0x020D). * - *

You can have MSG_VEL_ECEF inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_VEL_ECEF inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the velocity in Earth Centered Earth Fixed (ECEF) coordinates. The full - * GPS time is given by the preceding MSG_GPS_TIME with the matching time-of-week (tow). + * This message reports the velocity in Earth Centered Earth Fixed (ECEF) + * coordinates. The full GPS time is given by the preceding MSG_GPS_TIME with + * the matching time-of-week (tow). * - *

The values in this message are from GNSS measurements fused with inertial measurements. To get - * values from GNSS measurements only use MSG_VEL_ECEF_GNSS. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. To get values from GNSS measurements only use + * MSG_VEL_ECEF_GNSS. */ + public class MsgVelECEF extends SBPMessage { public static final int TYPE = 0x020D; + /** GPS Time of Week */ public long tow; - + /** Velocity ECEF X coordinate */ public int x; - + /** Velocity ECEF Y coordinate */ public int y; - + /** Velocity ECEF Z coordinate */ public int z; - + /** Velocity estimated standard deviation */ public int accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgVelECEF(int sender) { - super(sender, TYPE); - } - - public MsgVelECEF() { - super(TYPE); - } - - public MsgVelECEF(SBPMessage msg) throws SBPBinaryException { + public MsgVelECEF (int sender) { super(sender, TYPE); } + public MsgVelECEF () { super(TYPE); } + public MsgVelECEF (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgVelECEF, expected 525, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgVelECEF, expected 525, actual " + msg.type); } @Override @@ -78,7 +82,7 @@ protected void parse(Parser parser) throws SBPBinaryException { z = parser.getS32(); accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -89,7 +93,7 @@ protected void build(Builder builder) { builder.putS32(z); builder.putU16(accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgVelECEFCov.java b/java/src/com/swiftnav/sbp/navigation/MsgVelECEFCov.java index 4072469f3..10db17bda 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgVelECEFCov.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgVelECEFCov.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,80 +9,83 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_VEL_ECEF_COV (0x0215). +/** SBP class for message MSG_VEL_ECEF_COV (0x0215). * - *

You can have MSG_VEL_ECEF_COV inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_VEL_ECEF_COV inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the velocity in Earth Centered Earth Fixed (ECEF) coordinates. The full - * GPS time is given by the preceding MSG_GPS_TIME with the matching time-of-week (tow). + * This message reports the velocity in Earth Centered Earth Fixed (ECEF) + * coordinates. The full GPS time is given by the preceding MSG_GPS_TIME with + * the matching time-of-week (tow). * - *

The values in this message are from GNSS measurements fused with inertial measurements. To get - * values from GNSS measurements only use MSG_VEL_ECEF_COV_GNSS. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. To get values from GNSS measurements only use + * MSG_VEL_ECEF_COV_GNSS. */ + public class MsgVelECEFCov extends SBPMessage { public static final int TYPE = 0x0215; + /** GPS Time of Week */ public long tow; - + /** Velocity ECEF X coordinate */ public int x; - + /** Velocity ECEF Y coordinate */ public int y; - + /** Velocity ECEF Z coordinate */ public int z; - + /** Estimated variance of x */ public float cov_x_x; - + /** Estimated covariance of x and y */ public float cov_x_y; - + /** Estimated covariance of x and z */ public float cov_x_z; - + /** Estimated variance of y */ public float cov_y_y; - + /** Estimated covariance of y and z */ public float cov_y_z; - + /** Estimated variance of z */ public float cov_z_z; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgVelECEFCov(int sender) { - super(sender, TYPE); - } - - public MsgVelECEFCov() { - super(TYPE); - } - - public MsgVelECEFCov(SBPMessage msg) throws SBPBinaryException { + public MsgVelECEFCov (int sender) { super(sender, TYPE); } + public MsgVelECEFCov () { super(TYPE); } + public MsgVelECEFCov (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgVelECEFCov, expected 533, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgVelECEFCov, expected 533, actual " + msg.type); } @Override @@ -98,7 +102,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cov_y_z = parser.getFloat(); cov_z_z = parser.getFloat(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -114,7 +118,7 @@ protected void build(Builder builder) { builder.putFloat(cov_y_z); builder.putFloat(cov_z_z); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgVelECEFCovGnss.java b/java/src/com/swiftnav/sbp/navigation/MsgVelECEFCovGnss.java index 0f296e550..aaf20d45e 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgVelECEFCovGnss.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgVelECEFCovGnss.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,80 +9,82 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_VEL_ECEF_COV_GNSS (0x0235). +/** SBP class for message MSG_VEL_ECEF_COV_GNSS (0x0235). * - *

You can have MSG_VEL_ECEF_COV_GNSS inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_VEL_ECEF_COV_GNSS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the velocity in Earth Centered Earth Fixed (ECEF) coordinates. The full - * GPS time is given by the preceding MSG_GPS_TIME_GNSS with the matching time-of-week (tow). + * This message reports the velocity in Earth Centered Earth Fixed (ECEF) + * coordinates. The full GPS time is given by the preceding MSG_GPS_TIME_GNSS + * with the matching time-of-week (tow). * - *

The values in this message are from GNSS measurements only. To get values fused with inertial - * measurements use MSG_VEL_ECEF_COV. - */ + * The values in this message are from GNSS measurements only. To get values + * fused with inertial measurements use MSG_VEL_ECEF_COV. */ + public class MsgVelECEFCovGnss extends SBPMessage { public static final int TYPE = 0x0235; + /** GPS Time of Week */ public long tow; - + /** Velocity ECEF X coordinate */ public int x; - + /** Velocity ECEF Y coordinate */ public int y; - + /** Velocity ECEF Z coordinate */ public int z; - + /** Estimated variance of x */ public float cov_x_x; - + /** Estimated covariance of x and y */ public float cov_x_y; - + /** Estimated covariance of x and z */ public float cov_x_z; - + /** Estimated variance of y */ public float cov_y_y; - + /** Estimated covariance of y and z */ public float cov_y_z; - + /** Estimated variance of z */ public float cov_z_z; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgVelECEFCovGnss(int sender) { - super(sender, TYPE); - } - - public MsgVelECEFCovGnss() { - super(TYPE); - } - - public MsgVelECEFCovGnss(SBPMessage msg) throws SBPBinaryException { + public MsgVelECEFCovGnss (int sender) { super(sender, TYPE); } + public MsgVelECEFCovGnss () { super(TYPE); } + public MsgVelECEFCovGnss (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgVelECEFCovGnss, expected 565, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgVelECEFCovGnss, expected 565, actual " + msg.type); } @Override @@ -98,7 +101,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cov_y_z = parser.getFloat(); cov_z_z = parser.getFloat(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -114,7 +117,7 @@ protected void build(Builder builder) { builder.putFloat(cov_y_z); builder.putFloat(cov_z_z); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgVelECEFDepA.java b/java/src/com/swiftnav/sbp/navigation/MsgVelECEFDepA.java index 3829d226d..b5dd2e7a4 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgVelECEFDepA.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgVelECEFDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_VEL_ECEF_DEP_A (0x0204). +/** SBP class for message MSG_VEL_ECEF_DEP_A (0x0204). * - *

You can have MSG_VEL_ECEF_DEP_A inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_VEL_ECEF_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgVelECEFDepA extends SBPMessage { public static final int TYPE = 0x0204; + /** GPS Time of Week */ public long tow; - + /** Velocity ECEF X coordinate */ public int x; - + /** Velocity ECEF Y coordinate */ public int y; - + /** Velocity ECEF Z coordinate */ public int z; - + /** Velocity accuracy estimate (not implemented). Defaults to 0. */ public int accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags (reserved) */ public int flags; + - public MsgVelECEFDepA(int sender) { - super(sender, TYPE); - } - - public MsgVelECEFDepA() { - super(TYPE); - } - - public MsgVelECEFDepA(SBPMessage msg) throws SBPBinaryException { + public MsgVelECEFDepA (int sender) { super(sender, TYPE); } + public MsgVelECEFDepA () { super(TYPE); } + public MsgVelECEFDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgVelECEFDepA, expected 516, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgVelECEFDepA, expected 516, actual " + msg.type); } @Override @@ -74,7 +76,7 @@ protected void parse(Parser parser) throws SBPBinaryException { z = parser.getS32(); accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -85,7 +87,7 @@ protected void build(Builder builder) { builder.putS32(z); builder.putU16(accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgVelECEFGnss.java b/java/src/com/swiftnav/sbp/navigation/MsgVelECEFGnss.java index 92a9a7d8f..ced81f473 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgVelECEFGnss.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgVelECEFGnss.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,65 +9,67 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_VEL_ECEF_GNSS (0x022D). +/** SBP class for message MSG_VEL_ECEF_GNSS (0x022D). * - *

You can have MSG_VEL_ECEF_GNSS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_VEL_ECEF_GNSS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the velocity in Earth Centered Earth Fixed (ECEF) coordinates. The full - * GPS time is given by the preceding MSG_GPS_TIME_GNSS with the matching time-of-week (tow). + * This message reports the velocity in Earth Centered Earth Fixed (ECEF) + * coordinates. The full GPS time is given by the preceding MSG_GPS_TIME_GNSS + * with the matching time-of-week (tow). * - *

The values in this message are from GNSS measurements only. To get values fused with inertial - * measurements use MSG_VEL_ECEF. - */ + * The values in this message are from GNSS measurements only. To get values + * fused with inertial measurements use MSG_VEL_ECEF. */ + public class MsgVelECEFGnss extends SBPMessage { public static final int TYPE = 0x022D; + /** GPS Time of Week */ public long tow; - + /** Velocity ECEF X coordinate */ public int x; - + /** Velocity ECEF Y coordinate */ public int y; - + /** Velocity ECEF Z coordinate */ public int z; - + /** Velocity estimated standard deviation */ public int accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgVelECEFGnss(int sender) { - super(sender, TYPE); - } - - public MsgVelECEFGnss() { - super(TYPE); - } - - public MsgVelECEFGnss(SBPMessage msg) throws SBPBinaryException { + public MsgVelECEFGnss (int sender) { super(sender, TYPE); } + public MsgVelECEFGnss () { super(TYPE); } + public MsgVelECEFGnss (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgVelECEFGnss, expected 557, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgVelECEFGnss, expected 557, actual " + msg.type); } @Override @@ -78,7 +81,7 @@ protected void parse(Parser parser) throws SBPBinaryException { z = parser.getS32(); accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -89,7 +92,7 @@ protected void build(Builder builder) { builder.putS32(z); builder.putU16(accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgVelNED.java b/java/src/com/swiftnav/sbp/navigation/MsgVelNED.java index ed2a41567..88f0effbc 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgVelNED.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgVelNED.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,69 +9,72 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_VEL_NED (0x020E). +/** SBP class for message MSG_VEL_NED (0x020E). * - *

You can have MSG_VEL_NED inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_VEL_NED inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the velocity in local North East Down (NED) coordinates. The NED - * coordinate system is defined as the local WGS84 tangent plane centered at the current position. - * The full GPS time is given by the preceding MSG_GPS_TIME with the matching time-of-week (tow). + * This message reports the velocity in local North East Down (NED) + * coordinates. The NED coordinate system is defined as the local WGS84 + * tangent plane centered at the current position. The full GPS time is given + * by the preceding MSG_GPS_TIME with the matching time-of-week (tow). * - *

The values in this message are from GNSS measurements fused with inertial measurements. To get - * values from GNSS measurements only use MSG_VEL_NED_GNSS. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. To get values from GNSS measurements only use + * MSG_VEL_NED_GNSS. */ + public class MsgVelNED extends SBPMessage { public static final int TYPE = 0x020E; + /** GPS Time of Week */ public long tow; - + /** Velocity North coordinate */ public int n; - + /** Velocity East coordinate */ public int e; - + /** Velocity Down coordinate */ public int d; - + /** Horizontal velocity estimated standard deviation */ public int h_accuracy; - + /** Vertical velocity estimated standard deviation */ public int v_accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgVelNED(int sender) { - super(sender, TYPE); - } - - public MsgVelNED() { - super(TYPE); - } - - public MsgVelNED(SBPMessage msg) throws SBPBinaryException { + public MsgVelNED (int sender) { super(sender, TYPE); } + public MsgVelNED () { super(TYPE); } + public MsgVelNED (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgVelNED, expected 526, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgVelNED, expected 526, actual " + msg.type); } @Override @@ -83,7 +87,7 @@ protected void parse(Parser parser) throws SBPBinaryException { h_accuracy = parser.getU16(); v_accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -95,7 +99,7 @@ protected void build(Builder builder) { builder.putU16(h_accuracy); builder.putU16(v_accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgVelNEDCov.java b/java/src/com/swiftnav/sbp/navigation/MsgVelNEDCov.java index 0914f111e..a0685bf93 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgVelNEDCov.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgVelNEDCov.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,83 +9,86 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_VEL_NED_COV (0x0212). +/** SBP class for message MSG_VEL_NED_COV (0x0212). * - *

You can have MSG_VEL_NED_COV inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_VEL_NED_COV inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the velocity in local North East Down (NED) coordinates. The NED - * coordinate system is defined as the local WGS84 tangent plane centered at the current position. - * The full GPS time is given by the preceding MSG_GPS_TIME with the matching time-of-week (tow). - * This message is similar to the MSG_VEL_NED, but it includes the upper triangular portion of the - * 3x3 covariance matrix. + * This message reports the velocity in local North East Down (NED) + * coordinates. The NED coordinate system is defined as the local WGS84 + * tangent plane centered at the current position. The full GPS time is given + * by the preceding MSG_GPS_TIME with the matching time-of-week (tow). This + * message is similar to the MSG_VEL_NED, but it includes the upper triangular + * portion of the 3x3 covariance matrix. * - *

The values in this message are from GNSS measurements fused with inertial measurements. To get - * values from GNSS measurements only use MSG_VEL_NED_COV_GNSS. - */ + * The values in this message are from GNSS measurements fused with inertial + * measurements. To get values from GNSS measurements only use + * MSG_VEL_NED_COV_GNSS. */ + public class MsgVelNEDCov extends SBPMessage { public static final int TYPE = 0x0212; + /** GPS Time of Week */ public long tow; - + /** Velocity North coordinate */ public int n; - + /** Velocity East coordinate */ public int e; - + /** Velocity Down coordinate */ public int d; - + /** Estimated variance of northward measurement */ public float cov_n_n; - + /** Covariance of northward and eastward measurement */ public float cov_n_e; - + /** Covariance of northward and downward measurement */ public float cov_n_d; - + /** Estimated variance of eastward measurement */ public float cov_e_e; - + /** Covariance of eastward and downward measurement */ public float cov_e_d; - + /** Estimated variance of downward measurement */ public float cov_d_d; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgVelNEDCov(int sender) { - super(sender, TYPE); - } - - public MsgVelNEDCov() { - super(TYPE); - } - - public MsgVelNEDCov(SBPMessage msg) throws SBPBinaryException { + public MsgVelNEDCov (int sender) { super(sender, TYPE); } + public MsgVelNEDCov () { super(TYPE); } + public MsgVelNEDCov (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgVelNEDCov, expected 530, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgVelNEDCov, expected 530, actual " + msg.type); } @Override @@ -101,7 +105,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cov_e_d = parser.getFloat(); cov_d_d = parser.getFloat(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -117,7 +121,7 @@ protected void build(Builder builder) { builder.putFloat(cov_e_d); builder.putFloat(cov_d_d); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgVelNEDCovGnss.java b/java/src/com/swiftnav/sbp/navigation/MsgVelNEDCovGnss.java index 1b9e6148a..fea224d67 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgVelNEDCovGnss.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgVelNEDCovGnss.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,83 +9,85 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_VEL_NED_COV_GNSS (0x0232). +/** SBP class for message MSG_VEL_NED_COV_GNSS (0x0232). * - *

You can have MSG_VEL_NED_COV_GNSS inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_VEL_NED_COV_GNSS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the velocity in local North East Down (NED) coordinates. The NED - * coordinate system is defined as the local WGS84 tangent plane centered at the current position. - * The full GPS time is given by the preceding MSG_GPS_TIME_GNSS with the matching time-of-week - * (tow). This message is similar to the MSG_VEL_NED_GNSS, but it includes the upper triangular - * portion of the 3x3 covariance matrix. + * This message reports the velocity in local North East Down (NED) + * coordinates. The NED coordinate system is defined as the local WGS84 + * tangent plane centered at the current position. The full GPS time is given + * by the preceding MSG_GPS_TIME_GNSS with the matching time-of-week (tow). + * This message is similar to the MSG_VEL_NED_GNSS, but it includes the upper + * triangular portion of the 3x3 covariance matrix. * - *

The values in this message are from GNSS measurements only. To get values fused with inertial - * measurements use MSG_VEL_NED_COV. - */ + * The values in this message are from GNSS measurements only. To get values + * fused with inertial measurements use MSG_VEL_NED_COV. */ + public class MsgVelNEDCovGnss extends SBPMessage { public static final int TYPE = 0x0232; + /** GPS Time of Week */ public long tow; - + /** Velocity North coordinate */ public int n; - + /** Velocity East coordinate */ public int e; - + /** Velocity Down coordinate */ public int d; - + /** Estimated variance of northward measurement */ public float cov_n_n; - + /** Covariance of northward and eastward measurement */ public float cov_n_e; - + /** Covariance of northward and downward measurement */ public float cov_n_d; - + /** Estimated variance of eastward measurement */ public float cov_e_e; - + /** Covariance of eastward and downward measurement */ public float cov_e_d; - + /** Estimated variance of downward measurement */ public float cov_d_d; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgVelNEDCovGnss(int sender) { - super(sender, TYPE); - } - - public MsgVelNEDCovGnss() { - super(TYPE); - } - - public MsgVelNEDCovGnss(SBPMessage msg) throws SBPBinaryException { + public MsgVelNEDCovGnss (int sender) { super(sender, TYPE); } + public MsgVelNEDCovGnss () { super(TYPE); } + public MsgVelNEDCovGnss (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgVelNEDCovGnss, expected 562, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgVelNEDCovGnss, expected 562, actual " + msg.type); } @Override @@ -101,7 +104,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cov_e_d = parser.getFloat(); cov_d_d = parser.getFloat(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -117,7 +120,7 @@ protected void build(Builder builder) { builder.putFloat(cov_e_d); builder.putFloat(cov_d_d); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgVelNEDDepA.java b/java/src/com/swiftnav/sbp/navigation/MsgVelNEDDepA.java index 52ab73e02..6c04c7225 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgVelNEDDepA.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgVelNEDDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,64 +9,66 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_VEL_NED_DEP_A (0x0205). +/** SBP class for message MSG_VEL_NED_DEP_A (0x0205). * - *

You can have MSG_VEL_NED_DEP_A inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_VEL_NED_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgVelNEDDepA extends SBPMessage { public static final int TYPE = 0x0205; + /** GPS Time of Week */ public long tow; - + /** Velocity North coordinate */ public int n; - + /** Velocity East coordinate */ public int e; - + /** Velocity Down coordinate */ public int d; - - /** Horizontal velocity accuracy estimate (not implemented). Defaults to 0. */ + + /** Horizontal velocity accuracy estimate (not implemented). Defaults to + * 0. */ public int h_accuracy; - + /** Vertical velocity accuracy estimate (not implemented). Defaults to 0. */ public int v_accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags (reserved) */ public int flags; + - public MsgVelNEDDepA(int sender) { - super(sender, TYPE); - } - - public MsgVelNEDDepA() { - super(TYPE); - } - - public MsgVelNEDDepA(SBPMessage msg) throws SBPBinaryException { + public MsgVelNEDDepA (int sender) { super(sender, TYPE); } + public MsgVelNEDDepA () { super(TYPE); } + public MsgVelNEDDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgVelNEDDepA, expected 517, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgVelNEDDepA, expected 517, actual " + msg.type); } @Override @@ -78,7 +81,7 @@ protected void parse(Parser parser) throws SBPBinaryException { h_accuracy = parser.getU16(); v_accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -90,7 +93,7 @@ protected void build(Builder builder) { builder.putU16(h_accuracy); builder.putU16(v_accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/navigation/MsgVelNEDGnss.java b/java/src/com/swiftnav/sbp/navigation/MsgVelNEDGnss.java index 0fbb55683..930b08f5c 100644 --- a/java/src/com/swiftnav/sbp/navigation/MsgVelNEDGnss.java +++ b/java/src/com/swiftnav/sbp/navigation/MsgVelNEDGnss.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,70 +9,71 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.navigation; // This file was auto-generated from yaml/swiftnav/sbp/navigation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_VEL_NED_GNSS (0x022E). +/** SBP class for message MSG_VEL_NED_GNSS (0x022E). * - *

You can have MSG_VEL_NED_GNSS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_VEL_NED_GNSS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the velocity in local North East Down (NED) coordinates. The NED - * coordinate system is defined as the local WGS84 tangent plane centered at the current position. - * The full GPS time is given by the preceding MSG_GPS_TIME_GNSS with the matching time-of-week - * (tow). + * This message reports the velocity in local North East Down (NED) + * coordinates. The NED coordinate system is defined as the local WGS84 + * tangent plane centered at the current position. The full GPS time is given + * by the preceding MSG_GPS_TIME_GNSS with the matching time-of-week (tow). * - *

The values in this message are from GNSS measurements only. To get values fused with inertial - * measurements use MSG_VEL_NED. - */ + * The values in this message are from GNSS measurements only. To get values + * fused with inertial measurements use MSG_VEL_NED. */ + public class MsgVelNEDGnss extends SBPMessage { public static final int TYPE = 0x022E; + /** GPS Time of Week */ public long tow; - + /** Velocity North coordinate */ public int n; - + /** Velocity East coordinate */ public int e; - + /** Velocity Down coordinate */ public int d; - + /** Horizontal velocity estimated standard deviation */ public int h_accuracy; - + /** Vertical velocity estimated standard deviation */ public int v_accuracy; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgVelNEDGnss(int sender) { - super(sender, TYPE); - } - - public MsgVelNEDGnss() { - super(TYPE); - } - - public MsgVelNEDGnss(SBPMessage msg) throws SBPBinaryException { + public MsgVelNEDGnss (int sender) { super(sender, TYPE); } + public MsgVelNEDGnss () { super(TYPE); } + public MsgVelNEDGnss (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgVelNEDGnss, expected 558, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgVelNEDGnss, expected 558, actual " + msg.type); } @Override @@ -84,7 +86,7 @@ protected void parse(Parser parser) throws SBPBinaryException { h_accuracy = parser.getU16(); v_accuracy = parser.getU16(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -96,7 +98,7 @@ protected void build(Builder builder) { builder.putU16(h_accuracy); builder.putU16(v_accuracy); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/ndb/MsgNdbEvent.java b/java/src/com/swiftnav/sbp/ndb/MsgNdbEvent.java index 826095bc3..6734aef4e 100644 --- a/java/src/com/swiftnav/sbp/ndb/MsgNdbEvent.java +++ b/java/src/com/swiftnav/sbp/ndb/MsgNdbEvent.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,78 +9,73 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ndb; // This file was auto-generated from yaml/swiftnav/sbp/ndb.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import java.math.BigInteger; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_NDB_EVENT (0x0400). +/** SBP class for message MSG_NDB_EVENT (0x0400). * - *

You can have MSG_NDB_EVENT inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_NDB_EVENT inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message is sent out when an object is stored into NDB. If needed message could also be - * sent out when fetching an object from NDB. - */ + * This message is sent out when an object is stored into NDB. If needed + * message could also be sent out when fetching an object from NDB. */ + public class MsgNdbEvent extends SBPMessage { public static final int TYPE = 0x0400; + /** HW time in milliseconds. */ public BigInteger recv_time; - + /** Event type. */ public int event; - + /** Event object type. */ public int object_type; - + /** Event result. */ public int result; - + /** Data source for STORE event, reserved for other events. */ public int data_source; - - /** - * GNSS signal identifier, If object_type is Ephemeris OR Almanac, sid indicates for which - * signal the object belongs to. Reserved in other cases. - */ + + /** GNSS signal identifier, If object_type is Ephemeris OR Almanac, sid + * indicates for which signal the object belongs to. Reserved in other + * cases. */ public GnssSignal object_sid; - - /** - * GNSS signal identifier, If object_type is Almanac, Almanac WN, Iono OR L2C capabilities AND - * data_source is NDB_DS_RECEIVER sid indicates from which SV data was decoded. Reserved in - * other cases. - */ + + /** GNSS signal identifier, If object_type is Almanac, Almanac WN, Iono OR + * L2C capabilities AND data_source is NDB_DS_RECEIVER sid indicates from + * which SV data was decoded. Reserved in other cases. */ public GnssSignal src_sid; - - /** - * A unique identifier of the sending hardware. For v1.0, set to the 2 least significant bytes - * of the device serial number, valid only if data_source is NDB_DS_SBP. Reserved in case of - * other data_source. - */ + + /** A unique identifier of the sending hardware. For v1.0, set to the 2 + * least significant bytes of the device serial number, valid only if + * data_source is NDB_DS_SBP. Reserved in case of other data_source. */ public int original_sender; + - public MsgNdbEvent(int sender) { - super(sender, TYPE); - } - - public MsgNdbEvent() { - super(TYPE); - } - - public MsgNdbEvent(SBPMessage msg) throws SBPBinaryException { + public MsgNdbEvent (int sender) { super(sender, TYPE); } + public MsgNdbEvent () { super(TYPE); } + public MsgNdbEvent (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgNdbEvent, expected 1024, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgNdbEvent, expected 1024, actual " + msg.type); } @Override @@ -92,7 +88,7 @@ protected void parse(Parser parser) throws SBPBinaryException { data_source = parser.getU8(); object_sid = new GnssSignal().parse(parser); src_sid = new GnssSignal().parse(parser); - original_sender = parser.getU16(); + original_sender = parser.getU16(); } @Override @@ -104,7 +100,7 @@ protected void build(Builder builder) { builder.putU8(data_source); object_sid.build(builder); src_sid.build(builder); - builder.putU16(original_sender); + builder.putU16(original_sender); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/AlmanacCommonContent.java b/java/src/com/swiftnav/sbp/observation/AlmanacCommonContent.java index b58760340..8cbbf0d5d 100644 --- a/java/src/com/swiftnav/sbp/observation/AlmanacCommonContent.java +++ b/java/src/com/swiftnav/sbp/observation/AlmanacCommonContent.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,49 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class AlmanacCommonContent extends SBPStruct { - + /** GNSS signal identifier */ public GnssSignal sid; - + /** Reference time of almanac */ public GPSTimeSec toa; - + /** User Range Accuracy */ public double ura; - + /** Curve fit interval */ public long fit_interval; - + /** Status of almanac, 1 = valid, 0 = invalid */ public int valid; - - /** - * Satellite health status for GPS: - bits 5-7: NAV data health status. See IS-GPS-200H Table - * 20-VII: NAV Data Health Indications. - bits 0-4: Signal health status. See IS-GPS-200H Table - * 20-VIII. Codes for Health of SV Signal Components. - * - *

Satellite health status for GLO (see GLO ICD 5.1 table 5.1 for details): - bit 0: C(n), - * "unhealthy" flag that is transmitted within non-immediate data and indicates overall - * constellation status at the moment of almanac uploading. '0' indicates malfunction of - * n-satellite. '1' indicates that n-satellite is operational. - bit 1: Bn(ln), '0' indicates - * the satellite is operational and suitable for navigation. - */ + + /** Satellite health status for GPS: + * - bits 5-7: NAV data health status. See IS-GPS-200H + * Table 20-VII: NAV Data Health Indications. + * - bits 0-4: Signal health status. See IS-GPS-200H + * Table 20-VIII. Codes for Health of SV Signal + * Components. + * + * Satellite health status for GLO (see GLO ICD 5.1 table 5.1 for details): + * - bit 0: C(n), "unhealthy" flag that is transmitted within + * non-immediate data and indicates overall constellation status + * at the moment of almanac uploading. + * '0' indicates malfunction of n-satellite. + * '1' indicates that n-satellite is operational. + * - bit 1: Bn(ln), '0' indicates the satellite is operational + * and suitable for navigation. */ public int health_bits; + - public AlmanacCommonContent() {} + public AlmanacCommonContent () {} @Override public AlmanacCommonContent parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/AlmanacCommonContentDep.java b/java/src/com/swiftnav/sbp/observation/AlmanacCommonContentDep.java index 694572c52..6d087bec4 100644 --- a/java/src/com/swiftnav/sbp/observation/AlmanacCommonContentDep.java +++ b/java/src/com/swiftnav/sbp/observation/AlmanacCommonContentDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,49 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class AlmanacCommonContentDep extends SBPStruct { - + /** GNSS signal identifier */ public GnssSignalDep sid; - + /** Reference time of almanac */ public GPSTimeSec toa; - + /** User Range Accuracy */ public double ura; - + /** Curve fit interval */ public long fit_interval; - + /** Status of almanac, 1 = valid, 0 = invalid */ public int valid; - - /** - * Satellite health status for GPS: - bits 5-7: NAV data health status. See IS-GPS-200H Table - * 20-VII: NAV Data Health Indications. - bits 0-4: Signal health status. See IS-GPS-200H Table - * 20-VIII. Codes for Health of SV Signal Components. - * - *

Satellite health status for GLO (see GLO ICD 5.1 table 5.1 for details): - bit 0: C(n), - * "unhealthy" flag that is transmitted within non-immediate data and indicates overall - * constellation status at the moment of almanac uploading. '0' indicates malfunction of - * n-satellite. '1' indicates that n-satellite is operational. - bit 1: Bn(ln), '0' indicates - * the satellite is operational and suitable for navigation. - */ + + /** Satellite health status for GPS: + * - bits 5-7: NAV data health status. See IS-GPS-200H + * Table 20-VII: NAV Data Health Indications. + * - bits 0-4: Signal health status. See IS-GPS-200H + * Table 20-VIII. Codes for Health of SV Signal + * Components. + * + * Satellite health status for GLO (see GLO ICD 5.1 table 5.1 for details): + * - bit 0: C(n), "unhealthy" flag that is transmitted within + * non-immediate data and indicates overall constellation status + * at the moment of almanac uploading. + * '0' indicates malfunction of n-satellite. + * '1' indicates that n-satellite is operational. + * - bit 1: Bn(ln), '0' indicates the satellite is operational + * and suitable for navigation. */ public int health_bits; + - public AlmanacCommonContentDep() {} + public AlmanacCommonContentDep () {} @Override public AlmanacCommonContentDep parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/CarrierPhaseDepA.java b/java/src/com/swiftnav/sbp/observation/CarrierPhaseDepA.java index db4b7c6c8..ef97b26e0 100644 --- a/java/src/com/swiftnav/sbp/observation/CarrierPhaseDepA.java +++ b/java/src/com/swiftnav/sbp/observation/CarrierPhaseDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,27 +9,32 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class CarrierPhaseDepA extends SBPStruct { - + /** Carrier phase whole cycles */ public int i; - + /** Carrier phase fractional part */ public int f; + - public CarrierPhaseDepA() {} + public CarrierPhaseDepA () {} @Override public CarrierPhaseDepA parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/Doppler.java b/java/src/com/swiftnav/sbp/observation/Doppler.java index 22c7b9add..71501bc28 100644 --- a/java/src/com/swiftnav/sbp/observation/Doppler.java +++ b/java/src/com/swiftnav/sbp/observation/Doppler.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,27 +9,32 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class Doppler extends SBPStruct { - + /** Doppler whole Hz */ public int i; - + /** Doppler fractional part */ public int f; + - public Doppler() {} + public Doppler () {} @Override public Doppler parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/EphemerisCommonContent.java b/java/src/com/swiftnav/sbp/observation/EphemerisCommonContent.java index 74f882e0e..ecb91b743 100644 --- a/java/src/com/swiftnav/sbp/observation/EphemerisCommonContent.java +++ b/java/src/com/swiftnav/sbp/observation/EphemerisCommonContent.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,42 +9,47 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class EphemerisCommonContent extends SBPStruct { - + /** GNSS signal identifier (16 bit) */ public GnssSignal sid; - + /** Time of Ephemerides */ public GPSTimeSec toe; - + /** User Range Accuracy */ public float ura; - + /** Curve fit interval */ public long fit_interval; - + /** Status of ephemeris, 1 = valid, 0 = invalid */ public int valid; - - /** - * Satellite health status. GPS: ICD-GPS-200, chapter 20.3.3.3.1.4 SBAS: 0 = valid, non-zero = - * invalid GLO: 0 = valid, non-zero = invalid - */ + + /** Satellite health status. + * GPS: ICD-GPS-200, chapter 20.3.3.3.1.4 + * SBAS: 0 = valid, non-zero = invalid + * GLO: 0 = valid, non-zero = invalid */ public int health_bits; + - public EphemerisCommonContent() {} + public EphemerisCommonContent () {} @Override public EphemerisCommonContent parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/EphemerisCommonContentDepA.java b/java/src/com/swiftnav/sbp/observation/EphemerisCommonContentDepA.java index af8f5baf4..e08b4e930 100644 --- a/java/src/com/swiftnav/sbp/observation/EphemerisCommonContentDepA.java +++ b/java/src/com/swiftnav/sbp/observation/EphemerisCommonContentDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,42 +9,47 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class EphemerisCommonContentDepA extends SBPStruct { - + /** GNSS signal identifier */ public GnssSignalDep sid; - + /** Time of Ephemerides */ public GPSTimeDep toe; - + /** User Range Accuracy */ public double ura; - + /** Curve fit interval */ public long fit_interval; - + /** Status of ephemeris, 1 = valid, 0 = invalid */ public int valid; - - /** - * Satellite health status. GPS: ICD-GPS-200, chapter 20.3.3.3.1.4 SBAS: 0 = valid, non-zero = - * invalid GLO: 0 = valid, non-zero = invalid - */ + + /** Satellite health status. + * GPS: ICD-GPS-200, chapter 20.3.3.3.1.4 + * SBAS: 0 = valid, non-zero = invalid + * GLO: 0 = valid, non-zero = invalid */ public int health_bits; + - public EphemerisCommonContentDepA() {} + public EphemerisCommonContentDepA () {} @Override public EphemerisCommonContentDepA parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/EphemerisCommonContentDepB.java b/java/src/com/swiftnav/sbp/observation/EphemerisCommonContentDepB.java index a3ce051a4..573e6d1df 100644 --- a/java/src/com/swiftnav/sbp/observation/EphemerisCommonContentDepB.java +++ b/java/src/com/swiftnav/sbp/observation/EphemerisCommonContentDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,42 +9,46 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class EphemerisCommonContentDepB extends SBPStruct { - + /** GNSS signal identifier (16 bit) */ public GnssSignal sid; - + /** Time of Ephemerides */ public GPSTimeSec toe; - + /** User Range Accuracy */ public double ura; - + /** Curve fit interval */ public long fit_interval; - + /** Status of ephemeris, 1 = valid, 0 = invalid */ public int valid; - - /** - * Satellite health status. GPS: ICD-GPS-200, chapter 20.3.3.3.1.4 Others: 0 = valid, non-zero = - * invalid - */ + + /** Satellite health status. + * GPS: ICD-GPS-200, chapter 20.3.3.3.1.4 + * Others: 0 = valid, non-zero = invalid */ public int health_bits; + - public EphemerisCommonContentDepB() {} + public EphemerisCommonContentDepB () {} @Override public EphemerisCommonContentDepB parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/GnssCapb.java b/java/src/com/swiftnav/sbp/observation/GnssCapb.java index e7cacfdbf..88583a031 100644 --- a/java/src/com/swiftnav/sbp/observation/GnssCapb.java +++ b/java/src/com/swiftnav/sbp/observation/GnssCapb.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,73 +9,73 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import java.math.BigInteger; + import org.json.JSONObject; +import org.json.JSONArray; public class GnssCapb extends SBPStruct { - + /** GPS SV active mask */ public BigInteger gps_active; - + /** GPS L2C active mask */ public BigInteger gps_l2c; - + /** GPS L5 active mask */ public BigInteger gps_l5; - + /** GLO active mask */ public long glo_active; - + /** GLO L2OF active mask */ public long glo_l2of; - + /** GLO L3 active mask */ public long glo_l3; - - /** - * SBAS active mask (PRNs 120..158, AN 7/62.2.2-18/18 Table B-23, - * https://www.caat.or.th/wp-content/uploads/2018/03/SL-2018.18.E-1.pdf) - */ + + /** SBAS active mask (PRNs 120..158, AN 7/62.2.2-18/18 Table B-23, + * https://www.caat.or.th/wp-content/uploads/2018/03/SL-2018.18.E-1.pdf) */ public BigInteger sbas_active; - - /** - * SBAS L5 active mask (PRNs 120..158, AN 7/62.2.2-18/18 Table B-23, - * https://www.caat.or.th/wp-content/uploads/2018/03/SL-2018.18.E-1.pdf) - */ + + /** SBAS L5 active mask (PRNs 120..158, AN 7/62.2.2-18/18 Table B-23, + * https://www.caat.or.th/wp-content/uploads/2018/03/SL-2018.18.E-1.pdf) */ public BigInteger sbas_l5; - + /** BDS active mask */ public BigInteger bds_active; - + /** BDS D2NAV active mask */ public BigInteger bds_d2nav; - + /** BDS B2 active mask */ public BigInteger bds_b2; - + /** BDS B2A active mask */ public BigInteger bds_b2a; - + /** QZSS active mask */ public long qzss_active; - + /** GAL active mask */ public BigInteger gal_active; - + /** GAL E5 active mask */ public BigInteger gal_e5; + - public GnssCapb() {} + public GnssCapb () {} @Override public GnssCapb parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/MsgAlmanacGPS.java b/java/src/com/swiftnav/sbp/observation/MsgAlmanacGPS.java index 3a7bd181f..8306376ba 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgAlmanacGPS.java +++ b/java/src/com/swiftnav/sbp/observation/MsgAlmanacGPS.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,74 +9,75 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ALMANAC_GPS (0x0072). +/** SBP class for message MSG_ALMANAC_GPS (0x0072). * - *

You can have MSG_ALMANAC_GPS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_ALMANAC_GPS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The almanac message returns a set of satellite orbit parameters. Almanac data is not very - * precise and is considered valid for up to several months. Please see the Navstar GPS Space - * Segment/Navigation user interfaces (ICD- GPS-200, Chapter 20.3.3.5.1.2 Almanac Data) for more - * details. - */ + * The almanac message returns a set of satellite orbit parameters. Almanac + * data is not very precise and is considered valid for up to several months. + * Please see the Navstar GPS Space Segment/Navigation user interfaces (ICD- + * GPS-200, Chapter 20.3.3.5.1.2 Almanac Data) for more details. */ + public class MsgAlmanacGPS extends SBPMessage { public static final int TYPE = 0x0072; + /** Values common for all almanac types */ public AlmanacCommonContent common; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Polynomial clock correction coefficient (clock bias) */ public double af0; - + /** Polynomial clock correction coefficient (clock drift) */ public double af1; + - public MsgAlmanacGPS(int sender) { - super(sender, TYPE); - } - - public MsgAlmanacGPS() { - super(TYPE); - } - - public MsgAlmanacGPS(SBPMessage msg) throws SBPBinaryException { + public MsgAlmanacGPS (int sender) { super(sender, TYPE); } + public MsgAlmanacGPS () { super(TYPE); } + public MsgAlmanacGPS (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAlmanacGPS, expected 114, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAlmanacGPS, expected 114, actual " + msg.type); } @Override @@ -90,7 +92,7 @@ protected void parse(Parser parser) throws SBPBinaryException { w = parser.getDouble(); inc = parser.getDouble(); af0 = parser.getDouble(); - af1 = parser.getDouble(); + af1 = parser.getDouble(); } @Override @@ -104,7 +106,7 @@ protected void build(Builder builder) { builder.putDouble(w); builder.putDouble(inc); builder.putDouble(af0); - builder.putDouble(af1); + builder.putDouble(af1); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgAlmanacGPSDep.java b/java/src/com/swiftnav/sbp/observation/MsgAlmanacGPSDep.java index 197e2d35d..57bc4b375 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgAlmanacGPSDep.java +++ b/java/src/com/swiftnav/sbp/observation/MsgAlmanacGPSDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,71 +9,72 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ALMANAC_GPS_DEP (0x0070). +/** SBP class for message MSG_ALMANAC_GPS_DEP (0x0070). * - *

You can have MSG_ALMANAC_GPS_DEP inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_ALMANAC_GPS_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgAlmanacGPSDep extends SBPMessage { public static final int TYPE = 0x0070; + /** Values common for all almanac types */ public AlmanacCommonContentDep common; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Polynomial clock correction coefficient (clock bias) */ public double af0; - + /** Polynomial clock correction coefficient (clock drift) */ public double af1; + - public MsgAlmanacGPSDep(int sender) { - super(sender, TYPE); - } - - public MsgAlmanacGPSDep() { - super(TYPE); - } - - public MsgAlmanacGPSDep(SBPMessage msg) throws SBPBinaryException { + public MsgAlmanacGPSDep (int sender) { super(sender, TYPE); } + public MsgAlmanacGPSDep () { super(TYPE); } + public MsgAlmanacGPSDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAlmanacGPSDep, expected 112, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAlmanacGPSDep, expected 112, actual " + msg.type); } @Override @@ -87,7 +89,7 @@ protected void parse(Parser parser) throws SBPBinaryException { w = parser.getDouble(); inc = parser.getDouble(); af0 = parser.getDouble(); - af1 = parser.getDouble(); + af1 = parser.getDouble(); } @Override @@ -101,7 +103,7 @@ protected void build(Builder builder) { builder.putDouble(w); builder.putDouble(inc); builder.putDouble(af0); - builder.putDouble(af1); + builder.putDouble(af1); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgAlmanacGlo.java b/java/src/com/swiftnav/sbp/observation/MsgAlmanacGlo.java index 0e76876ab..f0f2fdae0 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgAlmanacGlo.java +++ b/java/src/com/swiftnav/sbp/observation/MsgAlmanacGlo.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,67 +9,70 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ALMANAC_GLO (0x0073). +/** SBP class for message MSG_ALMANAC_GLO (0x0073). * - *

You can have MSG_ALMANAC_GLO inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_ALMANAC_GLO inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The almanac message returns a set of satellite orbit parameters. Almanac data is not very - * precise and is considered valid for up to several months. Please see the GLO ICD 5.1 "Chapter 4.5 - * Non-immediate information and almanac" for details. - */ + * The almanac message returns a set of satellite orbit parameters. Almanac + * data is not very precise and is considered valid for up to several months. + * Please see the GLO ICD 5.1 "Chapter 4.5 Non-immediate information and + * almanac" for details. */ + public class MsgAlmanacGlo extends SBPMessage { public static final int TYPE = 0x0073; + /** Values common for all almanac types */ public AlmanacCommonContent common; - - /** Longitude of the first ascending node of the orbit in PZ-90.02 coordinate system */ + + /** Longitude of the first ascending node of the orbit in PZ-90.02 + * coordinate system */ public double lambda_na; - + /** Time of the first ascending node passage */ public double t_lambda_na; - + /** Value of inclination at instant of t_lambda */ public double i; - + /** Value of Draconian period at instant of t_lambda */ public double t; - + /** Rate of change of the Draconian period */ public double t_dot; - + /** Eccentricity at instant of t_lambda */ public double epsilon; - + /** Argument of perigee at instant of t_lambda */ public double omega; + - public MsgAlmanacGlo(int sender) { - super(sender, TYPE); - } - - public MsgAlmanacGlo() { - super(TYPE); - } - - public MsgAlmanacGlo(SBPMessage msg) throws SBPBinaryException { + public MsgAlmanacGlo (int sender) { super(sender, TYPE); } + public MsgAlmanacGlo () { super(TYPE); } + public MsgAlmanacGlo (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAlmanacGlo, expected 115, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAlmanacGlo, expected 115, actual " + msg.type); } @Override @@ -81,7 +85,7 @@ protected void parse(Parser parser) throws SBPBinaryException { t = parser.getDouble(); t_dot = parser.getDouble(); epsilon = parser.getDouble(); - omega = parser.getDouble(); + omega = parser.getDouble(); } @Override @@ -93,7 +97,7 @@ protected void build(Builder builder) { builder.putDouble(t); builder.putDouble(t_dot); builder.putDouble(epsilon); - builder.putDouble(omega); + builder.putDouble(omega); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgAlmanacGloDep.java b/java/src/com/swiftnav/sbp/observation/MsgAlmanacGloDep.java index 8575632a1..c7c55f0fe 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgAlmanacGloDep.java +++ b/java/src/com/swiftnav/sbp/observation/MsgAlmanacGloDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,65 +9,67 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ALMANAC_GLO_DEP (0x0071). +/** SBP class for message MSG_ALMANAC_GLO_DEP (0x0071). * - *

You can have MSG_ALMANAC_GLO_DEP inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_ALMANAC_GLO_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgAlmanacGloDep extends SBPMessage { public static final int TYPE = 0x0071; + /** Values common for all almanac types */ public AlmanacCommonContentDep common; - - /** Longitude of the first ascending node of the orbit in PZ-90.02 coordinate system */ + + /** Longitude of the first ascending node of the orbit in PZ-90.02 + * coordinate system */ public double lambda_na; - + /** Time of the first ascending node passage */ public double t_lambda_na; - + /** Value of inclination at instant of t_lambda */ public double i; - + /** Value of Draconian period at instant of t_lambda */ public double t; - + /** Rate of change of the Draconian period */ public double t_dot; - + /** Eccentricity at instant of t_lambda */ public double epsilon; - + /** Argument of perigee at instant of t_lambda */ public double omega; + - public MsgAlmanacGloDep(int sender) { - super(sender, TYPE); - } - - public MsgAlmanacGloDep() { - super(TYPE); - } - - public MsgAlmanacGloDep(SBPMessage msg) throws SBPBinaryException { + public MsgAlmanacGloDep (int sender) { super(sender, TYPE); } + public MsgAlmanacGloDep () { super(TYPE); } + public MsgAlmanacGloDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAlmanacGloDep, expected 113, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAlmanacGloDep, expected 113, actual " + msg.type); } @Override @@ -79,7 +82,7 @@ protected void parse(Parser parser) throws SBPBinaryException { t = parser.getDouble(); t_dot = parser.getDouble(); epsilon = parser.getDouble(); - omega = parser.getDouble(); + omega = parser.getDouble(); } @Override @@ -91,7 +94,7 @@ protected void build(Builder builder) { builder.putDouble(t); builder.putDouble(t_dot); builder.putDouble(epsilon); - builder.putDouble(omega); + builder.putDouble(omega); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgBasePosECEF.java b/java/src/com/swiftnav/sbp/observation/MsgBasePosECEF.java index 3e1a6f93b..912feb43c 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgBasePosECEF.java +++ b/java/src/com/swiftnav/sbp/observation/MsgBasePosECEF.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,53 +9,55 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_BASE_POS_ECEF (0x0048). + +/** SBP class for message MSG_BASE_POS_ECEF (0x0048). * - *

You can have MSG_BASE_POS_ECEF inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_BASE_POS_ECEF inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The base station position message is the position reported by the base station itself in - * absolute Earth Centered Earth Fixed coordinates. It is used for pseudo-absolute RTK positioning, - * and is required to be a high- accuracy surveyed location of the base station. Any error here will - * result in an error in the pseudo-absolute position output. - */ + * The base station position message is the position reported by the base + * station itself in absolute Earth Centered Earth Fixed coordinates. It is + * used for pseudo-absolute RTK positioning, and is required to be a high- + * accuracy surveyed location of the base station. Any error here will result + * in an error in the pseudo-absolute position output. */ + public class MsgBasePosECEF extends SBPMessage { public static final int TYPE = 0x0048; + /** ECEF X coordinate */ public double x; - + /** ECEF Y coordinate */ public double y; - + /** ECEF Z coordinate */ public double z; + - public MsgBasePosECEF(int sender) { - super(sender, TYPE); - } - - public MsgBasePosECEF() { - super(TYPE); - } - - public MsgBasePosECEF(SBPMessage msg) throws SBPBinaryException { + public MsgBasePosECEF (int sender) { super(sender, TYPE); } + public MsgBasePosECEF () { super(TYPE); } + public MsgBasePosECEF (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgBasePosECEF, expected 72, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgBasePosECEF, expected 72, actual " + msg.type); } @Override @@ -62,14 +65,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ x = parser.getDouble(); y = parser.getDouble(); - z = parser.getDouble(); + z = parser.getDouble(); } @Override protected void build(Builder builder) { builder.putDouble(x); builder.putDouble(y); - builder.putDouble(z); + builder.putDouble(z); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgBasePosLLH.java b/java/src/com/swiftnav/sbp/observation/MsgBasePosLLH.java index dfcacee3e..384177bd1 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgBasePosLLH.java +++ b/java/src/com/swiftnav/sbp/observation/MsgBasePosLLH.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,53 +9,54 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_BASE_POS_LLH (0x0044). + +/** SBP class for message MSG_BASE_POS_LLH (0x0044). * - *

You can have MSG_BASE_POS_LLH inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_BASE_POS_LLH inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The base station position message is the position reported by the base station itself. It is - * used for pseudo-absolute RTK positioning, and is required to be a high-accuracy surveyed location - * of the base station. Any error here will result in an error in the pseudo-absolute position - * output. - */ + * The base station position message is the position reported by the base + * station itself. It is used for pseudo-absolute RTK positioning, and is + * required to be a high-accuracy surveyed location of the base station. Any + * error here will result in an error in the pseudo-absolute position output. */ + public class MsgBasePosLLH extends SBPMessage { public static final int TYPE = 0x0044; + /** Latitude */ public double lat; - + /** Longitude */ public double lon; - + /** Height */ public double height; + - public MsgBasePosLLH(int sender) { - super(sender, TYPE); - } - - public MsgBasePosLLH() { - super(TYPE); - } - - public MsgBasePosLLH(SBPMessage msg) throws SBPBinaryException { + public MsgBasePosLLH (int sender) { super(sender, TYPE); } + public MsgBasePosLLH () { super(TYPE); } + public MsgBasePosLLH (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgBasePosLLH, expected 68, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgBasePosLLH, expected 68, actual " + msg.type); } @Override @@ -62,14 +64,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ lat = parser.getDouble(); lon = parser.getDouble(); - height = parser.getDouble(); + height = parser.getDouble(); } @Override protected void build(Builder builder) { builder.putDouble(lat); builder.putDouble(lon); - builder.putDouble(height); + builder.putDouble(height); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisBds.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisBds.java index 3cb15c6d9..e592b3956 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisBds.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisBds.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,121 +9,125 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_BDS (0x0089). +/** SBP class for message MSG_EPHEMERIS_BDS (0x0089). * - *

You can have MSG_EPHEMERIS_BDS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_BDS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The ephemeris message returns a set of satellite orbit parameters that is used to calculate - * BDS satellite position, velocity, and clock offset. Please see the BeiDou Navigation Satellite - * System SIS-ICD Version 2.1, Table 5-9 for more details. - */ + * The ephemeris message returns a set of satellite orbit parameters that is + * used to calculate BDS satellite position, velocity, and clock offset. + * Please see the BeiDou Navigation Satellite System SIS-ICD Version 2.1, + * Table 5-9 for more details. */ + public class MsgEphemerisBds extends SBPMessage { public static final int TYPE = 0x0089; + /** Values common for all ephemeris types */ public EphemerisCommonContent common; - + /** Group delay differential for B1 */ public float tgd1; - + /** Group delay differential for B2 */ public float tgd2; - + /** Amplitude of the sine harmonic correction term to the orbit radius */ public float c_rs; - + /** Amplitude of the cosine harmonic correction term to the orbit radius */ public float c_rc; - - /** Amplitude of the cosine harmonic correction term to the argument of latitude */ + + /** Amplitude of the cosine harmonic correction term to the argument of + * latitude */ public float c_uc; - - /** Amplitude of the sine harmonic correction term to the argument of latitude */ + + /** Amplitude of the sine harmonic correction term to the argument of + * latitude */ public float c_us; - - /** Amplitude of the cosine harmonic correction term to the angle of inclination */ + + /** Amplitude of the cosine harmonic correction term to the angle of + * inclination */ public float c_ic; - - /** Amplitude of the sine harmonic correction term to the angle of inclination */ + + /** Amplitude of the sine harmonic correction term to the angle of + * inclination */ public float c_is; - + /** Mean motion difference */ public double dn; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Inclination first derivative */ public double inc_dot; - + /** Polynomial clock correction coefficient (clock bias) */ public double af0; - + /** Polynomial clock correction coefficient (clock drift) */ public float af1; - + /** Polynomial clock correction coefficient (rate of clock drift) */ public float af2; - + /** Clock reference */ public GPSTimeSec toc; - - /** - * Issue of ephemeris data Calculated from the navigation data parameter t_oe per RTCM/CSNO - * recommendation: IODE = mod (t_oe / 720, 240) - */ + + /** Issue of ephemeris data + * Calculated from the navigation data parameter t_oe per RTCM/CSNO + * recommendation: IODE = mod (t_oe / 720, 240) */ public int iode; - - /** - * Issue of clock data Calculated from the navigation data parameter t_oe per RTCM/CSNO - * recommendation: IODE = mod (t_oc / 720, 240) - */ + + /** Issue of clock data + * Calculated from the navigation data parameter t_oe per RTCM/CSNO + * recommendation: IODE = mod (t_oc / 720, 240) */ public int iodc; + - public MsgEphemerisBds(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisBds() { - super(TYPE); - } - - public MsgEphemerisBds(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisBds (int sender) { super(sender, TYPE); } + public MsgEphemerisBds () { super(TYPE); } + public MsgEphemerisBds (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisBds, expected 137, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisBds, expected 137, actual " + msg.type); } @Override @@ -151,7 +156,7 @@ protected void parse(Parser parser) throws SBPBinaryException { af2 = parser.getFloat(); toc = new GPSTimeSec().parse(parser); iode = parser.getU8(); - iodc = parser.getU16(); + iodc = parser.getU16(); } @Override @@ -179,7 +184,7 @@ protected void build(Builder builder) { builder.putFloat(af2); toc.build(builder); builder.putU8(iode); - builder.putU16(iodc); + builder.putU16(iodc); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepA.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepA.java index e2dc74d42..f051292e0 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepA.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,119 +9,124 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_DEP_A (0x001A). +/** SBP class for message MSG_EPHEMERIS_DEP_A (0x001A). * - *

You can have MSG_EPHEMERIS_DEP_A inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEphemerisDepA extends SBPMessage { public static final int TYPE = 0x001A; + /** Group delay differential between L1 and L2 */ public double tgd; - + /** Amplitude of the sine harmonic correction term to the orbit radius */ public double c_rs; - + /** Amplitude of the cosine harmonic correction term to the orbit radius */ public double c_rc; - - /** Amplitude of the cosine harmonic correction term to the argument of latitude */ + + /** Amplitude of the cosine harmonic correction term to the argument of + * latitude */ public double c_uc; - - /** Amplitude of the sine harmonic correction term to the argument of latitude */ + + /** Amplitude of the sine harmonic correction term to the argument of + * latitude */ public double c_us; - - /** Amplitude of the cosine harmonic correction term to the angle of inclination */ + + /** Amplitude of the cosine harmonic correction term to the angle of + * inclination */ public double c_ic; - - /** Amplitude of the sine harmonic correction term to the angle of inclination */ + + /** Amplitude of the sine harmonic correction term to the angle of + * inclination */ public double c_is; - + /** Mean motion difference */ public double dn; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Inclination first derivative */ public double inc_dot; - + /** Polynomial clock correction coefficient (clock bias) */ public double af0; - + /** Polynomial clock correction coefficient (clock drift) */ public double af1; - + /** Polynomial clock correction coefficient (rate of clock drift) */ public double af2; - + /** Time of week */ public double toe_tow; - + /** Week number */ public int toe_wn; - + /** Clock reference time of week */ public double toc_tow; - + /** Clock reference week number */ public int toc_wn; - + /** Is valid? */ public int valid; - + /** Satellite is healthy? */ public int healthy; - + /** PRN being tracked */ public int prn; + - public MsgEphemerisDepA(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisDepA() { - super(TYPE); - } - - public MsgEphemerisDepA(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisDepA (int sender) { super(sender, TYPE); } + public MsgEphemerisDepA () { super(TYPE); } + public MsgEphemerisDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisDepA, expected 26, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisDepA, expected 26, actual " + msg.type); } @Override @@ -151,7 +157,7 @@ protected void parse(Parser parser) throws SBPBinaryException { toc_wn = parser.getU16(); valid = parser.getU8(); healthy = parser.getU8(); - prn = parser.getU8(); + prn = parser.getU8(); } @Override @@ -181,7 +187,7 @@ protected void build(Builder builder) { builder.putU16(toc_wn); builder.putU8(valid); builder.putU8(healthy); - builder.putU8(prn); + builder.putU8(prn); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepB.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepB.java index e871c6ecb..eabad8dcd 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepB.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,122 +9,127 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_DEP_B (0x0046). +/** SBP class for message MSG_EPHEMERIS_DEP_B (0x0046). * - *

You can have MSG_EPHEMERIS_DEP_B inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_DEP_B inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEphemerisDepB extends SBPMessage { public static final int TYPE = 0x0046; + /** Group delay differential between L1 and L2 */ public double tgd; - + /** Amplitude of the sine harmonic correction term to the orbit radius */ public double c_rs; - + /** Amplitude of the cosine harmonic correction term to the orbit radius */ public double c_rc; - - /** Amplitude of the cosine harmonic correction term to the argument of latitude */ + + /** Amplitude of the cosine harmonic correction term to the argument of + * latitude */ public double c_uc; - - /** Amplitude of the sine harmonic correction term to the argument of latitude */ + + /** Amplitude of the sine harmonic correction term to the argument of + * latitude */ public double c_us; - - /** Amplitude of the cosine harmonic correction term to the angle of inclination */ + + /** Amplitude of the cosine harmonic correction term to the angle of + * inclination */ public double c_ic; - - /** Amplitude of the sine harmonic correction term to the angle of inclination */ + + /** Amplitude of the sine harmonic correction term to the angle of + * inclination */ public double c_is; - + /** Mean motion difference */ public double dn; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Inclination first derivative */ public double inc_dot; - + /** Polynomial clock correction coefficient (clock bias) */ public double af0; - + /** Polynomial clock correction coefficient (clock drift) */ public double af1; - + /** Polynomial clock correction coefficient (rate of clock drift) */ public double af2; - + /** Time of week */ public double toe_tow; - + /** Week number */ public int toe_wn; - + /** Clock reference time of week */ public double toc_tow; - + /** Clock reference week number */ public int toc_wn; - + /** Is valid? */ public int valid; - + /** Satellite is healthy? */ public int healthy; - + /** PRN being tracked */ public int prn; - + /** Issue of ephemeris data */ public int iode; + - public MsgEphemerisDepB(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisDepB() { - super(TYPE); - } - - public MsgEphemerisDepB(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisDepB (int sender) { super(sender, TYPE); } + public MsgEphemerisDepB () { super(TYPE); } + public MsgEphemerisDepB (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisDepB, expected 70, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisDepB, expected 70, actual " + msg.type); } @Override @@ -155,7 +161,7 @@ protected void parse(Parser parser) throws SBPBinaryException { valid = parser.getU8(); healthy = parser.getU8(); prn = parser.getU8(); - iode = parser.getU8(); + iode = parser.getU8(); } @Override @@ -186,7 +192,7 @@ protected void build(Builder builder) { builder.putU8(valid); builder.putU8(healthy); builder.putU8(prn); - builder.putU8(iode); + builder.putU8(iode); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepC.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepC.java index 6c4003a80..f9d289932 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepC.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepC.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,128 +9,133 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_DEP_C (0x0047). +/** SBP class for message MSG_EPHEMERIS_DEP_C (0x0047). * - *

You can have MSG_EPHEMERIS_DEP_C inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_DEP_C inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEphemerisDepC extends SBPMessage { public static final int TYPE = 0x0047; + /** Group delay differential between L1 and L2 */ public double tgd; - + /** Amplitude of the sine harmonic correction term to the orbit radius */ public double c_rs; - + /** Amplitude of the cosine harmonic correction term to the orbit radius */ public double c_rc; - - /** Amplitude of the cosine harmonic correction term to the argument of latitude */ + + /** Amplitude of the cosine harmonic correction term to the argument of + * latitude */ public double c_uc; - - /** Amplitude of the sine harmonic correction term to the argument of latitude */ + + /** Amplitude of the sine harmonic correction term to the argument of + * latitude */ public double c_us; - - /** Amplitude of the cosine harmonic correction term to the angle of inclination */ + + /** Amplitude of the cosine harmonic correction term to the angle of + * inclination */ public double c_ic; - - /** Amplitude of the sine harmonic correction term to the angle of inclination */ + + /** Amplitude of the sine harmonic correction term to the angle of + * inclination */ public double c_is; - + /** Mean motion difference */ public double dn; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Inclination first derivative */ public double inc_dot; - + /** Polynomial clock correction coefficient (clock bias) */ public double af0; - + /** Polynomial clock correction coefficient (clock drift) */ public double af1; - + /** Polynomial clock correction coefficient (rate of clock drift) */ public double af2; - + /** Time of week */ public double toe_tow; - + /** Week number */ public int toe_wn; - + /** Clock reference time of week */ public double toc_tow; - + /** Clock reference week number */ public int toc_wn; - + /** Is valid? */ public int valid; - + /** Satellite is healthy? */ public int healthy; - + /** GNSS signal identifier */ public GnssSignalDep sid; - + /** Issue of ephemeris data */ public int iode; - + /** Issue of clock data */ public int iodc; - + /** Reserved field */ public long reserved; + - public MsgEphemerisDepC(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisDepC() { - super(TYPE); - } - - public MsgEphemerisDepC(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisDepC (int sender) { super(sender, TYPE); } + public MsgEphemerisDepC () { super(TYPE); } + public MsgEphemerisDepC (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisDepC, expected 71, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisDepC, expected 71, actual " + msg.type); } @Override @@ -163,7 +169,7 @@ protected void parse(Parser parser) throws SBPBinaryException { sid = new GnssSignalDep().parse(parser); iode = parser.getU8(); iodc = parser.getU16(); - reserved = parser.getU32(); + reserved = parser.getU32(); } @Override @@ -196,7 +202,7 @@ protected void build(Builder builder) { sid.build(builder); builder.putU8(iode); builder.putU16(iodc); - builder.putU32(reserved); + builder.putU32(reserved); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepD.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepD.java index a0815238e..553993158 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepD.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisDepD.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,128 +9,133 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_DEP_D (0x0080). +/** SBP class for message MSG_EPHEMERIS_DEP_D (0x0080). * - *

You can have MSG_EPHEMERIS_DEP_D inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_DEP_D inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEphemerisDepD extends SBPMessage { public static final int TYPE = 0x0080; + /** Group delay differential between L1 and L2 */ public double tgd; - + /** Amplitude of the sine harmonic correction term to the orbit radius */ public double c_rs; - + /** Amplitude of the cosine harmonic correction term to the orbit radius */ public double c_rc; - - /** Amplitude of the cosine harmonic correction term to the argument of latitude */ + + /** Amplitude of the cosine harmonic correction term to the argument of + * latitude */ public double c_uc; - - /** Amplitude of the sine harmonic correction term to the argument of latitude */ + + /** Amplitude of the sine harmonic correction term to the argument of + * latitude */ public double c_us; - - /** Amplitude of the cosine harmonic correction term to the angle of inclination */ + + /** Amplitude of the cosine harmonic correction term to the angle of + * inclination */ public double c_ic; - - /** Amplitude of the sine harmonic correction term to the angle of inclination */ + + /** Amplitude of the sine harmonic correction term to the angle of + * inclination */ public double c_is; - + /** Mean motion difference */ public double dn; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Inclination first derivative */ public double inc_dot; - + /** Polynomial clock correction coefficient (clock bias) */ public double af0; - + /** Polynomial clock correction coefficient (clock drift) */ public double af1; - + /** Polynomial clock correction coefficient (rate of clock drift) */ public double af2; - + /** Time of week */ public double toe_tow; - + /** Week number */ public int toe_wn; - + /** Clock reference time of week */ public double toc_tow; - + /** Clock reference week number */ public int toc_wn; - + /** Is valid? */ public int valid; - + /** Satellite is healthy? */ public int healthy; - + /** GNSS signal identifier */ public GnssSignalDep sid; - + /** Issue of ephemeris data */ public int iode; - + /** Issue of clock data */ public int iodc; - + /** Reserved field */ public long reserved; + - public MsgEphemerisDepD(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisDepD() { - super(TYPE); - } - - public MsgEphemerisDepD(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisDepD (int sender) { super(sender, TYPE); } + public MsgEphemerisDepD () { super(TYPE); } + public MsgEphemerisDepD (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisDepD, expected 128, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisDepD, expected 128, actual " + msg.type); } @Override @@ -163,7 +169,7 @@ protected void parse(Parser parser) throws SBPBinaryException { sid = new GnssSignalDep().parse(parser); iode = parser.getU8(); iodc = parser.getU16(); - reserved = parser.getU32(); + reserved = parser.getU32(); } @Override @@ -196,7 +202,7 @@ protected void build(Builder builder) { sid.build(builder); builder.putU8(iode); builder.putU16(iodc); - builder.putU32(reserved); + builder.putU32(reserved); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGPS.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGPS.java index 37ecd4754..0dcb1ca7e 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGPS.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGPS.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,112 +9,118 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_GPS (0x008A). +/** SBP class for message MSG_EPHEMERIS_GPS (0x008A). * - *

You can have MSG_EPHEMERIS_GPS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_GPS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The ephemeris message returns a set of satellite orbit parameters that is used to calculate - * GPS satellite position, velocity, and clock offset. Please see the Navstar GPS Space - * Segment/Navigation user interfaces (ICD- GPS-200, Table 20-III) for more details. - */ + * The ephemeris message returns a set of satellite orbit parameters that is + * used to calculate GPS satellite position, velocity, and clock offset. + * Please see the Navstar GPS Space Segment/Navigation user interfaces (ICD- + * GPS-200, Table 20-III) for more details. */ + public class MsgEphemerisGPS extends SBPMessage { public static final int TYPE = 0x008A; + /** Values common for all ephemeris types */ public EphemerisCommonContent common; - + /** Group delay differential between L1 and L2 */ public float tgd; - + /** Amplitude of the sine harmonic correction term to the orbit radius */ public float c_rs; - + /** Amplitude of the cosine harmonic correction term to the orbit radius */ public float c_rc; - - /** Amplitude of the cosine harmonic correction term to the argument of latitude */ + + /** Amplitude of the cosine harmonic correction term to the argument of + * latitude */ public float c_uc; - - /** Amplitude of the sine harmonic correction term to the argument of latitude */ + + /** Amplitude of the sine harmonic correction term to the argument of + * latitude */ public float c_us; - - /** Amplitude of the cosine harmonic correction term to the angle of inclination */ + + /** Amplitude of the cosine harmonic correction term to the angle of + * inclination */ public float c_ic; - - /** Amplitude of the sine harmonic correction term to the angle of inclination */ + + /** Amplitude of the sine harmonic correction term to the angle of + * inclination */ public float c_is; - + /** Mean motion difference */ public double dn; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Inclination first derivative */ public double inc_dot; - + /** Polynomial clock correction coefficient (clock bias) */ public float af0; - + /** Polynomial clock correction coefficient (clock drift) */ public float af1; - + /** Polynomial clock correction coefficient (rate of clock drift) */ public float af2; - + /** Clock reference */ public GPSTimeSec toc; - + /** Issue of ephemeris data */ public int iode; - + /** Issue of clock data */ public int iodc; + - public MsgEphemerisGPS(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisGPS() { - super(TYPE); - } - - public MsgEphemerisGPS(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisGPS (int sender) { super(sender, TYPE); } + public MsgEphemerisGPS () { super(TYPE); } + public MsgEphemerisGPS (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisGPS, expected 138, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisGPS, expected 138, actual " + msg.type); } @Override @@ -141,7 +148,7 @@ protected void parse(Parser parser) throws SBPBinaryException { af2 = parser.getFloat(); toc = new GPSTimeSec().parse(parser); iode = parser.getU8(); - iodc = parser.getU16(); + iodc = parser.getU16(); } @Override @@ -168,7 +175,7 @@ protected void build(Builder builder) { builder.putFloat(af2); toc.build(builder); builder.putU8(iode); - builder.putU16(iodc); + builder.putU16(iodc); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGPSDepE.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGPSDepE.java index 9a356623e..3db369cc3 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGPSDepE.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGPSDepE.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,110 +9,115 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_GPS_DEP_E (0x0081). +/** SBP class for message MSG_EPHEMERIS_GPS_DEP_E (0x0081). * - *

You can have MSG_EPHEMERIS_GPS_DEP_E inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_GPS_DEP_E inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEphemerisGPSDepE extends SBPMessage { public static final int TYPE = 0x0081; + /** Values common for all ephemeris types */ public EphemerisCommonContentDepA common; - + /** Group delay differential between L1 and L2 */ public double tgd; - + /** Amplitude of the sine harmonic correction term to the orbit radius */ public double c_rs; - + /** Amplitude of the cosine harmonic correction term to the orbit radius */ public double c_rc; - - /** Amplitude of the cosine harmonic correction term to the argument of latitude */ + + /** Amplitude of the cosine harmonic correction term to the argument of + * latitude */ public double c_uc; - - /** Amplitude of the sine harmonic correction term to the argument of latitude */ + + /** Amplitude of the sine harmonic correction term to the argument of + * latitude */ public double c_us; - - /** Amplitude of the cosine harmonic correction term to the angle of inclination */ + + /** Amplitude of the cosine harmonic correction term to the angle of + * inclination */ public double c_ic; - - /** Amplitude of the sine harmonic correction term to the angle of inclination */ + + /** Amplitude of the sine harmonic correction term to the angle of + * inclination */ public double c_is; - + /** Mean motion difference */ public double dn; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Inclination first derivative */ public double inc_dot; - + /** Polynomial clock correction coefficient (clock bias) */ public double af0; - + /** Polynomial clock correction coefficient (clock drift) */ public double af1; - + /** Polynomial clock correction coefficient (rate of clock drift) */ public double af2; - + /** Clock reference */ public GPSTimeDep toc; - + /** Issue of ephemeris data */ public int iode; - + /** Issue of clock data */ public int iodc; + - public MsgEphemerisGPSDepE(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisGPSDepE() { - super(TYPE); - } - - public MsgEphemerisGPSDepE(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisGPSDepE (int sender) { super(sender, TYPE); } + public MsgEphemerisGPSDepE () { super(TYPE); } + public MsgEphemerisGPSDepE (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisGPSDepE, expected 129, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisGPSDepE, expected 129, actual " + msg.type); } @Override @@ -139,7 +145,7 @@ protected void parse(Parser parser) throws SBPBinaryException { af2 = parser.getDouble(); toc = new GPSTimeDep().parse(parser); iode = parser.getU8(); - iodc = parser.getU16(); + iodc = parser.getU16(); } @Override @@ -166,7 +172,7 @@ protected void build(Builder builder) { builder.putDouble(af2); toc.build(builder); builder.putU8(iode); - builder.putU16(iodc); + builder.putU16(iodc); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGPSDepF.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGPSDepF.java index f5797e63a..e256eb5b7 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGPSDepF.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGPSDepF.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,110 +9,115 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_GPS_DEP_F (0x0086). +/** SBP class for message MSG_EPHEMERIS_GPS_DEP_F (0x0086). * - *

You can have MSG_EPHEMERIS_GPS_DEP_F inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_GPS_DEP_F inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEphemerisGPSDepF extends SBPMessage { public static final int TYPE = 0x0086; + /** Values common for all ephemeris types */ public EphemerisCommonContentDepB common; - + /** Group delay differential between L1 and L2 */ public double tgd; - + /** Amplitude of the sine harmonic correction term to the orbit radius */ public double c_rs; - + /** Amplitude of the cosine harmonic correction term to the orbit radius */ public double c_rc; - - /** Amplitude of the cosine harmonic correction term to the argument of latitude */ + + /** Amplitude of the cosine harmonic correction term to the argument of + * latitude */ public double c_uc; - - /** Amplitude of the sine harmonic correction term to the argument of latitude */ + + /** Amplitude of the sine harmonic correction term to the argument of + * latitude */ public double c_us; - - /** Amplitude of the cosine harmonic correction term to the angle of inclination */ + + /** Amplitude of the cosine harmonic correction term to the angle of + * inclination */ public double c_ic; - - /** Amplitude of the sine harmonic correction term to the angle of inclination */ + + /** Amplitude of the sine harmonic correction term to the angle of + * inclination */ public double c_is; - + /** Mean motion difference */ public double dn; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Inclination first derivative */ public double inc_dot; - + /** Polynomial clock correction coefficient (clock bias) */ public double af0; - + /** Polynomial clock correction coefficient (clock drift) */ public double af1; - + /** Polynomial clock correction coefficient (rate of clock drift) */ public double af2; - + /** Clock reference */ public GPSTimeSec toc; - + /** Issue of ephemeris data */ public int iode; - + /** Issue of clock data */ public int iodc; + - public MsgEphemerisGPSDepF(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisGPSDepF() { - super(TYPE); - } - - public MsgEphemerisGPSDepF(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisGPSDepF (int sender) { super(sender, TYPE); } + public MsgEphemerisGPSDepF () { super(TYPE); } + public MsgEphemerisGPSDepF (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisGPSDepF, expected 134, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisGPSDepF, expected 134, actual " + msg.type); } @Override @@ -139,7 +145,7 @@ protected void parse(Parser parser) throws SBPBinaryException { af2 = parser.getDouble(); toc = new GPSTimeSec().parse(parser); iode = parser.getU8(); - iodc = parser.getU16(); + iodc = parser.getU16(); } @Override @@ -166,7 +172,7 @@ protected void build(Builder builder) { builder.putDouble(af2); toc.build(builder); builder.putU8(iode); - builder.putU16(iodc); + builder.putU16(iodc); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGal.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGal.java index c3bb171dc..f4700d2d0 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGal.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGal.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,118 +9,124 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_GAL (0x008D). +/** SBP class for message MSG_EPHEMERIS_GAL (0x008D). * - *

You can have MSG_EPHEMERIS_GAL inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_GAL inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The ephemeris message returns a set of satellite orbit parameters that is used to calculate - * Galileo satellite position, velocity, and clock offset. Please see the Signal In Space ICD OS SIS - * ICD, Issue 1.3, December 2016 for more details. - */ + * The ephemeris message returns a set of satellite orbit parameters that is + * used to calculate Galileo satellite position, velocity, and clock offset. + * Please see the Signal In Space ICD OS SIS ICD, Issue 1.3, December 2016 for + * more details. */ + public class MsgEphemerisGal extends SBPMessage { public static final int TYPE = 0x008D; + /** Values common for all ephemeris types */ public EphemerisCommonContent common; - + /** E1-E5a Broadcast Group Delay */ public float bgd_e1e5a; - + /** E1-E5b Broadcast Group Delay */ public float bgd_e1e5b; - + /** Amplitude of the sine harmonic correction term to the orbit radius */ public float c_rs; - + /** Amplitude of the cosine harmonic correction term to the orbit radius */ public float c_rc; - - /** Amplitude of the cosine harmonic correction term to the argument of latitude */ + + /** Amplitude of the cosine harmonic correction term to the argument of + * latitude */ public float c_uc; - - /** Amplitude of the sine harmonic correction term to the argument of latitude */ + + /** Amplitude of the sine harmonic correction term to the argument of + * latitude */ public float c_us; - - /** Amplitude of the cosine harmonic correction term to the angle of inclination */ + + /** Amplitude of the cosine harmonic correction term to the angle of + * inclination */ public float c_ic; - - /** Amplitude of the sine harmonic correction term to the angle of inclination */ + + /** Amplitude of the sine harmonic correction term to the angle of + * inclination */ public float c_is; - + /** Mean motion difference */ public double dn; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Inclination first derivative */ public double inc_dot; - + /** Polynomial clock correction coefficient (clock bias) */ public double af0; - + /** Polynomial clock correction coefficient (clock drift) */ public double af1; - + /** Polynomial clock correction coefficient (rate of clock drift) */ public float af2; - + /** Clock reference */ public GPSTimeSec toc; - + /** Issue of data (IODnav) */ public int iode; - + /** Issue of data (IODnav). Always equal to iode */ public int iodc; - + /** 0=I/NAV, 1=F/NAV */ public int source; + - public MsgEphemerisGal(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisGal() { - super(TYPE); - } - - public MsgEphemerisGal(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisGal (int sender) { super(sender, TYPE); } + public MsgEphemerisGal () { super(TYPE); } + public MsgEphemerisGal (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisGal, expected 141, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisGal, expected 141, actual " + msg.type); } @Override @@ -149,7 +156,7 @@ protected void parse(Parser parser) throws SBPBinaryException { toc = new GPSTimeSec().parse(parser); iode = parser.getU16(); iodc = parser.getU16(); - source = parser.getU8(); + source = parser.getU8(); } @Override @@ -178,7 +185,7 @@ protected void build(Builder builder) { toc.build(builder); builder.putU16(iode); builder.putU16(iodc); - builder.putU8(source); + builder.putU8(source); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGalDepA.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGalDepA.java index 3d3cc6333..93f9c8445 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGalDepA.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGalDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,113 +9,118 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_GAL_DEP_A (0x0095). +/** SBP class for message MSG_EPHEMERIS_GAL_DEP_A (0x0095). * - *

You can have MSG_EPHEMERIS_GAL_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_GAL_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEphemerisGalDepA extends SBPMessage { public static final int TYPE = 0x0095; + /** Values common for all ephemeris types */ public EphemerisCommonContent common; - + /** E1-E5a Broadcast Group Delay */ public float bgd_e1e5a; - + /** E1-E5b Broadcast Group Delay */ public float bgd_e1e5b; - + /** Amplitude of the sine harmonic correction term to the orbit radius */ public float c_rs; - + /** Amplitude of the cosine harmonic correction term to the orbit radius */ public float c_rc; - - /** Amplitude of the cosine harmonic correction term to the argument of latitude */ + + /** Amplitude of the cosine harmonic correction term to the argument of + * latitude */ public float c_uc; - - /** Amplitude of the sine harmonic correction term to the argument of latitude */ + + /** Amplitude of the sine harmonic correction term to the argument of + * latitude */ public float c_us; - - /** Amplitude of the cosine harmonic correction term to the angle of inclination */ + + /** Amplitude of the cosine harmonic correction term to the angle of + * inclination */ public float c_ic; - - /** Amplitude of the sine harmonic correction term to the angle of inclination */ + + /** Amplitude of the sine harmonic correction term to the angle of + * inclination */ public float c_is; - + /** Mean motion difference */ public double dn; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Inclination first derivative */ public double inc_dot; - + /** Polynomial clock correction coefficient (clock bias) */ public double af0; - + /** Polynomial clock correction coefficient (clock drift) */ public double af1; - + /** Polynomial clock correction coefficient (rate of clock drift) */ public float af2; - + /** Clock reference */ public GPSTimeSec toc; - + /** Issue of data (IODnav) */ public int iode; - + /** Issue of data (IODnav). Always equal to iode */ public int iodc; + - public MsgEphemerisGalDepA(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisGalDepA() { - super(TYPE); - } - - public MsgEphemerisGalDepA(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisGalDepA (int sender) { super(sender, TYPE); } + public MsgEphemerisGalDepA () { super(TYPE); } + public MsgEphemerisGalDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisGalDepA, expected 149, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisGalDepA, expected 149, actual " + msg.type); } @Override @@ -143,7 +149,7 @@ protected void parse(Parser parser) throws SBPBinaryException { af2 = parser.getFloat(); toc = new GPSTimeSec().parse(parser); iode = parser.getU16(); - iodc = parser.getU16(); + iodc = parser.getU16(); } @Override @@ -171,7 +177,7 @@ protected void build(Builder builder) { builder.putFloat(af2); toc.build(builder); builder.putU16(iode); - builder.putU16(iodc); + builder.putU16(iodc); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGlo.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGlo.java index 51cf98a6a..c95d0a8d8 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGlo.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGlo.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,71 +9,72 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_EPHEMERIS_GLO (0x008B). + +/** SBP class for message MSG_EPHEMERIS_GLO (0x008B). * - *

You can have MSG_EPHEMERIS_GLO inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_GLO inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The ephemeris message returns a set of satellite orbit parameters that is used to calculate - * GLO satellite position, velocity, and clock offset. Please see the GLO ICD 5.1 "Table 4.5 - * Characteristics of words of immediate information (ephemeris parameters)" for more details. - */ + * The ephemeris message returns a set of satellite orbit parameters that is + * used to calculate GLO satellite position, velocity, and clock offset. + * Please see the GLO ICD 5.1 "Table 4.5 Characteristics of words of immediate + * information (ephemeris parameters)" for more details. */ + public class MsgEphemerisGlo extends SBPMessage { public static final int TYPE = 0x008B; + /** Values common for all ephemeris types */ public EphemerisCommonContent common; - + /** Relative deviation of predicted carrier frequency from nominal */ public float gamma; - + /** Correction to the SV time */ public float tau; - + /** Equipment delay between L1 and L2 */ public float d_tau; - + /** Position of the SV at tb in PZ-90.02 coordinates system */ public double[] pos; - + /** Velocity vector of the SV at tb in PZ-90.02 coordinates system */ public double[] vel; - + /** Acceleration vector of the SV at tb in PZ-90.02 coordinates sys */ public float[] acc; - + /** Frequency slot. FCN+8 (that is [1..14]). 0 or 0xFF for invalid */ public int fcn; - + /** Issue of data. Equal to the 7 bits of the immediate data word t_b */ public int iod; + - public MsgEphemerisGlo(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisGlo() { - super(TYPE); - } - - public MsgEphemerisGlo(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisGlo (int sender) { super(sender, TYPE); } + public MsgEphemerisGlo () { super(TYPE); } + public MsgEphemerisGlo (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisGlo, expected 139, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisGlo, expected 139, actual " + msg.type); } @Override @@ -86,7 +88,7 @@ protected void parse(Parser parser) throws SBPBinaryException { vel = parser.getArrayofDouble(3); acc = parser.getArrayofFloat(3); fcn = parser.getU8(); - iod = parser.getU8(); + iod = parser.getU8(); } @Override @@ -99,7 +101,7 @@ protected void build(Builder builder) { builder.putArrayofDouble(vel, 3); builder.putArrayofFloat(acc, 3); builder.putU8(fcn); - builder.putU8(iod); + builder.putU8(iod); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepA.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepA.java index c076ebb48..27f45cd57 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepA.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,60 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_GLO_DEP_A (0x0083). +/** SBP class for message MSG_EPHEMERIS_GLO_DEP_A (0x0083). * - *

You can have MSG_EPHEMERIS_GLO_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_GLO_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEphemerisGloDepA extends SBPMessage { public static final int TYPE = 0x0083; + /** Values common for all ephemeris types */ public EphemerisCommonContentDepA common; - + /** Relative deviation of predicted carrier frequency from nominal */ public double gamma; - + /** Correction to the SV time */ public double tau; - + /** Position of the SV at tb in PZ-90.02 coordinates system */ public double[] pos; - + /** Velocity vector of the SV at tb in PZ-90.02 coordinates system */ public double[] vel; - + /** Acceleration vector of the SV at tb in PZ-90.02 coordinates sys */ public double[] acc; + - public MsgEphemerisGloDepA(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisGloDepA() { - super(TYPE); - } - - public MsgEphemerisGloDepA(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisGloDepA (int sender) { super(sender, TYPE); } + public MsgEphemerisGloDepA () { super(TYPE); } + public MsgEphemerisGloDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisGloDepA, expected 131, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisGloDepA, expected 131, actual " + msg.type); } @Override @@ -72,7 +73,7 @@ protected void parse(Parser parser) throws SBPBinaryException { tau = parser.getDouble(); pos = parser.getArrayofDouble(3); vel = parser.getArrayofDouble(3); - acc = parser.getArrayofDouble(3); + acc = parser.getArrayofDouble(3); } @Override @@ -82,7 +83,7 @@ protected void build(Builder builder) { builder.putDouble(tau); builder.putArrayofDouble(pos, 3); builder.putArrayofDouble(vel, 3); - builder.putArrayofDouble(acc, 3); + builder.putArrayofDouble(acc, 3); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepB.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepB.java index 905219a1f..7ce649dce 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepB.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,60 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_GLO_DEP_B (0x0085). +/** SBP class for message MSG_EPHEMERIS_GLO_DEP_B (0x0085). * - *

You can have MSG_EPHEMERIS_GLO_DEP_B inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_GLO_DEP_B inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEphemerisGloDepB extends SBPMessage { public static final int TYPE = 0x0085; + /** Values common for all ephemeris types */ public EphemerisCommonContentDepB common; - + /** Relative deviation of predicted carrier frequency from nominal */ public double gamma; - + /** Correction to the SV time */ public double tau; - + /** Position of the SV at tb in PZ-90.02 coordinates system */ public double[] pos; - + /** Velocity vector of the SV at tb in PZ-90.02 coordinates system */ public double[] vel; - + /** Acceleration vector of the SV at tb in PZ-90.02 coordinates sys */ public double[] acc; + - public MsgEphemerisGloDepB(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisGloDepB() { - super(TYPE); - } - - public MsgEphemerisGloDepB(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisGloDepB (int sender) { super(sender, TYPE); } + public MsgEphemerisGloDepB () { super(TYPE); } + public MsgEphemerisGloDepB (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisGloDepB, expected 133, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisGloDepB, expected 133, actual " + msg.type); } @Override @@ -72,7 +73,7 @@ protected void parse(Parser parser) throws SBPBinaryException { tau = parser.getDouble(); pos = parser.getArrayofDouble(3); vel = parser.getArrayofDouble(3); - acc = parser.getArrayofDouble(3); + acc = parser.getArrayofDouble(3); } @Override @@ -82,7 +83,7 @@ protected void build(Builder builder) { builder.putDouble(tau); builder.putArrayofDouble(pos, 3); builder.putArrayofDouble(vel, 3); - builder.putArrayofDouble(acc, 3); + builder.putArrayofDouble(acc, 3); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepC.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepC.java index 7d8d7be18..9ce7836aa 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepC.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepC.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,68 +9,69 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_GLO_DEP_C (0x0087). +/** SBP class for message MSG_EPHEMERIS_GLO_DEP_C (0x0087). * - *

You can have MSG_EPHEMERIS_GLO_DEP_C inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_GLO_DEP_C inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The ephemeris message returns a set of satellite orbit parameters that is used to calculate - * GLO satellite position, velocity, and clock offset. Please see the GLO ICD 5.1 "Table 4.5 - * Characteristics of words of immediate information (ephemeris parameters)" for more details. - */ + * The ephemeris message returns a set of satellite orbit parameters that is + * used to calculate GLO satellite position, velocity, and clock offset. + * Please see the GLO ICD 5.1 "Table 4.5 Characteristics of words of immediate + * information (ephemeris parameters)" for more details. */ + public class MsgEphemerisGloDepC extends SBPMessage { public static final int TYPE = 0x0087; + /** Values common for all ephemeris types */ public EphemerisCommonContentDepB common; - + /** Relative deviation of predicted carrier frequency from nominal */ public double gamma; - + /** Correction to the SV time */ public double tau; - + /** Equipment delay between L1 and L2 */ public double d_tau; - + /** Position of the SV at tb in PZ-90.02 coordinates system */ public double[] pos; - + /** Velocity vector of the SV at tb in PZ-90.02 coordinates system */ public double[] vel; - + /** Acceleration vector of the SV at tb in PZ-90.02 coordinates sys */ public double[] acc; - + /** Frequency slot. FCN+8 (that is [1..14]). 0 or 0xFF for invalid */ public int fcn; + - public MsgEphemerisGloDepC(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisGloDepC() { - super(TYPE); - } - - public MsgEphemerisGloDepC(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisGloDepC (int sender) { super(sender, TYPE); } + public MsgEphemerisGloDepC () { super(TYPE); } + public MsgEphemerisGloDepC (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisGloDepC, expected 135, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisGloDepC, expected 135, actual " + msg.type); } @Override @@ -82,7 +84,7 @@ protected void parse(Parser parser) throws SBPBinaryException { pos = parser.getArrayofDouble(3); vel = parser.getArrayofDouble(3); acc = parser.getArrayofDouble(3); - fcn = parser.getU8(); + fcn = parser.getU8(); } @Override @@ -94,7 +96,7 @@ protected void build(Builder builder) { builder.putArrayofDouble(pos, 3); builder.putArrayofDouble(vel, 3); builder.putArrayofDouble(acc, 3); - builder.putU8(fcn); + builder.putU8(fcn); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepD.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepD.java index 1845375f4..7e1e029d1 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepD.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisGloDepD.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,70 +9,70 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_EPHEMERIS_GLO_DEP_D (0x0088). + +/** SBP class for message MSG_EPHEMERIS_GLO_DEP_D (0x0088). * - *

You can have MSG_EPHEMERIS_GLO_DEP_D inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_GLO_DEP_D inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This observation message has been deprecated in favor of ephemeris message using floats for - * size reduction. - */ + * This observation message has been deprecated in favor of ephemeris message + * using floats for size reduction. */ + public class MsgEphemerisGloDepD extends SBPMessage { public static final int TYPE = 0x0088; + /** Values common for all ephemeris types */ public EphemerisCommonContentDepB common; - + /** Relative deviation of predicted carrier frequency from nominal */ public double gamma; - + /** Correction to the SV time */ public double tau; - + /** Equipment delay between L1 and L2 */ public double d_tau; - + /** Position of the SV at tb in PZ-90.02 coordinates system */ public double[] pos; - + /** Velocity vector of the SV at tb in PZ-90.02 coordinates system */ public double[] vel; - + /** Acceleration vector of the SV at tb in PZ-90.02 coordinates sys */ public double[] acc; - + /** Frequency slot. FCN+8 (that is [1..14]). 0 or 0xFF for invalid */ public int fcn; - + /** Issue of data. Equal to the 7 bits of the immediate data word t_b */ public int iod; + - public MsgEphemerisGloDepD(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisGloDepD() { - super(TYPE); - } - - public MsgEphemerisGloDepD(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisGloDepD (int sender) { super(sender, TYPE); } + public MsgEphemerisGloDepD () { super(TYPE); } + public MsgEphemerisGloDepD (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisGloDepD, expected 136, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisGloDepD, expected 136, actual " + msg.type); } @Override @@ -85,7 +86,7 @@ protected void parse(Parser parser) throws SBPBinaryException { vel = parser.getArrayofDouble(3); acc = parser.getArrayofDouble(3); fcn = parser.getU8(); - iod = parser.getU8(); + iod = parser.getU8(); } @Override @@ -98,7 +99,7 @@ protected void build(Builder builder) { builder.putArrayofDouble(vel, 3); builder.putArrayofDouble(acc, 3); builder.putU8(fcn); - builder.putU8(iod); + builder.putU8(iod); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisQzss.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisQzss.java index 1093573c7..83b68c5a8 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisQzss.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisQzss.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,111 +9,116 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_QZSS (0x008E). +/** SBP class for message MSG_EPHEMERIS_QZSS (0x008E). * - *

You can have MSG_EPHEMERIS_QZSS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_QZSS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The ephemeris message returns a set of satellite orbit parameters that is used to calculate - * QZSS satellite position, velocity, and clock offset. - */ + * The ephemeris message returns a set of satellite orbit parameters that is + * used to calculate QZSS satellite position, velocity, and clock offset. */ + public class MsgEphemerisQzss extends SBPMessage { public static final int TYPE = 0x008E; + /** Values common for all ephemeris types */ public EphemerisCommonContent common; - + /** Group delay differential between L1 and L2 */ public float tgd; - + /** Amplitude of the sine harmonic correction term to the orbit radius */ public float c_rs; - + /** Amplitude of the cosine harmonic correction term to the orbit radius */ public float c_rc; - - /** Amplitude of the cosine harmonic correction term to the argument of latitude */ + + /** Amplitude of the cosine harmonic correction term to the argument of + * latitude */ public float c_uc; - - /** Amplitude of the sine harmonic correction term to the argument of latitude */ + + /** Amplitude of the sine harmonic correction term to the argument of + * latitude */ public float c_us; - - /** Amplitude of the cosine harmonic correction term to the angle of inclination */ + + /** Amplitude of the cosine harmonic correction term to the angle of + * inclination */ public float c_ic; - - /** Amplitude of the sine harmonic correction term to the angle of inclination */ + + /** Amplitude of the sine harmonic correction term to the angle of + * inclination */ public float c_is; - + /** Mean motion difference */ public double dn; - + /** Mean anomaly at reference time */ public double m0; - + /** Eccentricity of satellite orbit */ public double ecc; - + /** Square root of the semi-major axis of orbit */ public double sqrta; - + /** Longitude of ascending node of orbit plane at weekly epoch */ public double omega0; - + /** Rate of right ascension */ public double omegadot; - + /** Argument of perigee */ public double w; - + /** Inclination */ public double inc; - + /** Inclination first derivative */ public double inc_dot; - + /** Polynomial clock correction coefficient (clock bias) */ public float af0; - + /** Polynomial clock correction coefficient (clock drift) */ public float af1; - + /** Polynomial clock correction coefficient (rate of clock drift) */ public float af2; - + /** Clock reference */ public GPSTimeSec toc; - + /** Issue of ephemeris data */ public int iode; - + /** Issue of clock data */ public int iodc; + - public MsgEphemerisQzss(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisQzss() { - super(TYPE); - } - - public MsgEphemerisQzss(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisQzss (int sender) { super(sender, TYPE); } + public MsgEphemerisQzss () { super(TYPE); } + public MsgEphemerisQzss (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisQzss, expected 142, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisQzss, expected 142, actual " + msg.type); } @Override @@ -140,7 +146,7 @@ protected void parse(Parser parser) throws SBPBinaryException { af2 = parser.getFloat(); toc = new GPSTimeSec().parse(parser); iode = parser.getU8(); - iodc = parser.getU16(); + iodc = parser.getU16(); } @Override @@ -167,7 +173,7 @@ protected void build(Builder builder) { builder.putFloat(af2); toc.build(builder); builder.putU8(iode); - builder.putU16(iodc); + builder.putU16(iodc); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisSbas.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisSbas.java index 76e0ed1ac..2be805f4f 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisSbas.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisSbas.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,52 +9,53 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgEphemerisSbas extends SBPMessage { public static final int TYPE = 0x008C; + /** Values common for all ephemeris types */ public EphemerisCommonContent common; - + /** Position of the GEO at time toe */ public double[] pos; - + /** Velocity of the GEO at time toe */ public float[] vel; - + /** Acceleration of the GEO at time toe */ public float[] acc; - + /** Time offset of the GEO clock w.r.t. SBAS Network Time */ public float a_gf0; - + /** Drift of the GEO clock w.r.t. SBAS Network Time */ public float a_gf1; + - public MsgEphemerisSbas(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisSbas() { - super(TYPE); - } - - public MsgEphemerisSbas(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisSbas (int sender) { super(sender, TYPE); } + public MsgEphemerisSbas () { super(TYPE); } + public MsgEphemerisSbas (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisSbas, expected 140, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisSbas, expected 140, actual " + msg.type); } @Override @@ -64,7 +66,7 @@ protected void parse(Parser parser) throws SBPBinaryException { vel = parser.getArrayofFloat(3); acc = parser.getArrayofFloat(3); a_gf0 = parser.getFloat(); - a_gf1 = parser.getFloat(); + a_gf1 = parser.getFloat(); } @Override @@ -74,7 +76,7 @@ protected void build(Builder builder) { builder.putArrayofFloat(vel, 3); builder.putArrayofFloat(acc, 3); builder.putFloat(a_gf0); - builder.putFloat(a_gf1); + builder.putFloat(a_gf1); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisSbasDepA.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisSbasDepA.java index 7821627ae..bfa139a86 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisSbasDepA.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisSbasDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,60 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_SBAS_DEP_A (0x0082). +/** SBP class for message MSG_EPHEMERIS_SBAS_DEP_A (0x0082). * - *

You can have MSG_EPHEMERIS_SBAS_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_SBAS_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEphemerisSbasDepA extends SBPMessage { public static final int TYPE = 0x0082; + /** Values common for all ephemeris types */ public EphemerisCommonContentDepA common; - + /** Position of the GEO at time toe */ public double[] pos; - + /** Velocity of the GEO at time toe */ public double[] vel; - + /** Acceleration of the GEO at time toe */ public double[] acc; - + /** Time offset of the GEO clock w.r.t. SBAS Network Time */ public double a_gf0; - + /** Drift of the GEO clock w.r.t. SBAS Network Time */ public double a_gf1; + - public MsgEphemerisSbasDepA(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisSbasDepA() { - super(TYPE); - } - - public MsgEphemerisSbasDepA(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisSbasDepA (int sender) { super(sender, TYPE); } + public MsgEphemerisSbasDepA () { super(TYPE); } + public MsgEphemerisSbasDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisSbasDepA, expected 130, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisSbasDepA, expected 130, actual " + msg.type); } @Override @@ -72,7 +73,7 @@ protected void parse(Parser parser) throws SBPBinaryException { vel = parser.getArrayofDouble(3); acc = parser.getArrayofDouble(3); a_gf0 = parser.getDouble(); - a_gf1 = parser.getDouble(); + a_gf1 = parser.getDouble(); } @Override @@ -82,7 +83,7 @@ protected void build(Builder builder) { builder.putArrayofDouble(vel, 3); builder.putArrayofDouble(acc, 3); builder.putDouble(a_gf0); - builder.putDouble(a_gf1); + builder.putDouble(a_gf1); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgEphemerisSbasDepB.java b/java/src/com/swiftnav/sbp/observation/MsgEphemerisSbasDepB.java index 027ab7564..a48dda992 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgEphemerisSbasDepB.java +++ b/java/src/com/swiftnav/sbp/observation/MsgEphemerisSbasDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,60 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_EPHEMERIS_SBAS_DEP_B (0x0084). +/** SBP class for message MSG_EPHEMERIS_SBAS_DEP_B (0x0084). * - *

You can have MSG_EPHEMERIS_SBAS_DEP_B inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_EPHEMERIS_SBAS_DEP_B inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEphemerisSbasDepB extends SBPMessage { public static final int TYPE = 0x0084; + /** Values common for all ephemeris types */ public EphemerisCommonContentDepB common; - + /** Position of the GEO at time toe */ public double[] pos; - + /** Velocity of the GEO at time toe */ public double[] vel; - + /** Acceleration of the GEO at time toe */ public double[] acc; - + /** Time offset of the GEO clock w.r.t. SBAS Network Time */ public double a_gf0; - + /** Drift of the GEO clock w.r.t. SBAS Network Time */ public double a_gf1; + - public MsgEphemerisSbasDepB(int sender) { - super(sender, TYPE); - } - - public MsgEphemerisSbasDepB() { - super(TYPE); - } - - public MsgEphemerisSbasDepB(SBPMessage msg) throws SBPBinaryException { + public MsgEphemerisSbasDepB (int sender) { super(sender, TYPE); } + public MsgEphemerisSbasDepB () { super(TYPE); } + public MsgEphemerisSbasDepB (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEphemerisSbasDepB, expected 132, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEphemerisSbasDepB, expected 132, actual " + msg.type); } @Override @@ -72,7 +73,7 @@ protected void parse(Parser parser) throws SBPBinaryException { vel = parser.getArrayofDouble(3); acc = parser.getArrayofDouble(3); a_gf0 = parser.getDouble(); - a_gf1 = parser.getDouble(); + a_gf1 = parser.getDouble(); } @Override @@ -82,7 +83,7 @@ protected void build(Builder builder) { builder.putArrayofDouble(vel, 3); builder.putArrayofDouble(acc, 3); builder.putDouble(a_gf0); - builder.putDouble(a_gf1); + builder.putDouble(a_gf1); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgGloBiases.java b/java/src/com/swiftnav/sbp/observation/MsgGloBiases.java index 15eb76238..e2767816f 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgGloBiases.java +++ b/java/src/com/swiftnav/sbp/observation/MsgGloBiases.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,59 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_GLO_BIASES (0x0075). + +/** SBP class for message MSG_GLO_BIASES (0x0075). * - *

You can have MSG_GLO_BIASES inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_GLO_BIASES inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The GLONASS L1/L2 Code-Phase biases allows to perform GPS+GLONASS integer ambiguity resolution - * for baselines with mixed receiver types (e.g. receiver of different manufacturers). - */ + * The GLONASS L1/L2 Code-Phase biases allows to perform GPS+GLONASS integer + * ambiguity resolution for baselines with mixed receiver types (e.g. receiver + * of different manufacturers). */ + public class MsgGloBiases extends SBPMessage { public static final int TYPE = 0x0075; + /** GLONASS FDMA signals mask */ public int mask; - + /** GLONASS L1 C/A Code-Phase Bias */ public int l1ca_bias; - + /** GLONASS L1 P Code-Phase Bias */ public int l1p_bias; - + /** GLONASS L2 C/A Code-Phase Bias */ public int l2ca_bias; - + /** GLONASS L2 P Code-Phase Bias */ public int l2p_bias; + - public MsgGloBiases(int sender) { - super(sender, TYPE); - } - - public MsgGloBiases() { - super(TYPE); - } - - public MsgGloBiases(SBPMessage msg) throws SBPBinaryException { + public MsgGloBiases (int sender) { super(sender, TYPE); } + public MsgGloBiases () { super(TYPE); } + public MsgGloBiases (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgGloBiases, expected 117, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgGloBiases, expected 117, actual " + msg.type); } @Override @@ -68,7 +71,7 @@ protected void parse(Parser parser) throws SBPBinaryException { l1ca_bias = parser.getS16(); l1p_bias = parser.getS16(); l2ca_bias = parser.getS16(); - l2p_bias = parser.getS16(); + l2p_bias = parser.getS16(); } @Override @@ -77,7 +80,7 @@ protected void build(Builder builder) { builder.putS16(l1ca_bias); builder.putS16(l1p_bias); builder.putS16(l2ca_bias); - builder.putS16(l2p_bias); + builder.putS16(l2p_bias); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgGnssCapb.java b/java/src/com/swiftnav/sbp/observation/MsgGnssCapb.java index c75d58ed9..52724ab28 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgGnssCapb.java +++ b/java/src/com/swiftnav/sbp/observation/MsgGnssCapb.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_GNSS_CAPB (0x0096). +/** SBP class for message MSG_GNSS_CAPB (0x0096). * - *

You can have MSG_GNSS_CAPB inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_GNSS_CAPB inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Bit masks of signal capabilities for each GNSS satellite PRN. Please see ICD-GPS-200 (Chapter - * 20.3.3.5.1.4) for more details. - */ + * Bit masks of signal capabilities for each GNSS satellite PRN. + * Please see ICD-GPS-200 (Chapter 20.3.3.5.1.4) for more details. */ + public class MsgGnssCapb extends SBPMessage { public static final int TYPE = 0x0096; + /** Navigation Message Correction Table Validity Time */ public GPSTimeSec t_nmct; - + /** GNSS capabilities masks */ public GnssCapb gc; + - public MsgGnssCapb(int sender) { - super(sender, TYPE); - } - - public MsgGnssCapb() { - super(TYPE); - } - - public MsgGnssCapb(SBPMessage msg) throws SBPBinaryException { + public MsgGnssCapb (int sender) { super(sender, TYPE); } + public MsgGnssCapb () { super(TYPE); } + public MsgGnssCapb (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgGnssCapb, expected 150, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgGnssCapb, expected 150, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ t_nmct = new GPSTimeSec().parse(parser); - gc = new GnssCapb().parse(parser); + gc = new GnssCapb().parse(parser); } @Override protected void build(Builder builder) { t_nmct.build(builder); - gc.build(builder); + gc.build(builder); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgGroupDelay.java b/java/src/com/swiftnav/sbp/observation/MsgGroupDelay.java index e6afaa9cd..ccaff1672 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgGroupDelay.java +++ b/java/src/com/swiftnav/sbp/observation/MsgGroupDelay.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,59 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_GROUP_DELAY (0x0094). + +/** SBP class for message MSG_GROUP_DELAY (0x0094). * - *

You can have MSG_GROUP_DELAY inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_GROUP_DELAY inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Please see ICD-GPS-200 (30.3.3.3.1.1) for more details. - */ + * Please see ICD-GPS-200 (30.3.3.3.1.1) for more details. */ + public class MsgGroupDelay extends SBPMessage { public static final int TYPE = 0x0094; + /** Data Predict Time of Week */ public GPSTimeSec t_op; - + /** GNSS signal identifier */ public GnssSignal sid; - - /** - * bit-field indicating validity of the values, LSB indicating tgd validity etc. 1 = value is - * valid, 0 = value is not valid. - */ + + /** bit-field indicating validity of the values, LSB indicating tgd + * validity etc. 1 = value is valid, 0 = value is not valid. */ public int valid; - + public int tgd; - + public int isc_l1ca; - + public int isc_l2c; + - public MsgGroupDelay(int sender) { - super(sender, TYPE); - } - - public MsgGroupDelay() { - super(TYPE); - } - - public MsgGroupDelay(SBPMessage msg) throws SBPBinaryException { + public MsgGroupDelay (int sender) { super(sender, TYPE); } + public MsgGroupDelay () { super(TYPE); } + public MsgGroupDelay (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgGroupDelay, expected 148, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgGroupDelay, expected 148, actual " + msg.type); } @Override @@ -71,7 +71,7 @@ protected void parse(Parser parser) throws SBPBinaryException { valid = parser.getU8(); tgd = parser.getS16(); isc_l1ca = parser.getS16(); - isc_l2c = parser.getS16(); + isc_l2c = parser.getS16(); } @Override @@ -81,7 +81,7 @@ protected void build(Builder builder) { builder.putU8(valid); builder.putS16(tgd); builder.putS16(isc_l1ca); - builder.putS16(isc_l2c); + builder.putS16(isc_l2c); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgGroupDelayDepA.java b/java/src/com/swiftnav/sbp/observation/MsgGroupDelayDepA.java index 5941342e0..fad95bd78 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgGroupDelayDepA.java +++ b/java/src/com/swiftnav/sbp/observation/MsgGroupDelayDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,59 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_GROUP_DELAY_DEP_A (0x0092). + +/** SBP class for message MSG_GROUP_DELAY_DEP_A (0x0092). * - *

You can have MSG_GROUP_DELAY_DEP_A inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_GROUP_DELAY_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgGroupDelayDepA extends SBPMessage { public static final int TYPE = 0x0092; + /** Data Predict Time of Week */ public GPSTimeDep t_op; - + /** Satellite number */ public int prn; - - /** - * bit-field indicating validity of the values, LSB indicating tgd validity etc. 1 = value is - * valid, 0 = value is not valid. - */ + + /** bit-field indicating validity of the values, LSB indicating tgd + * validity etc. 1 = value is valid, 0 = value is not valid. */ public int valid; - + public int tgd; - + public int isc_l1ca; - + public int isc_l2c; + - public MsgGroupDelayDepA(int sender) { - super(sender, TYPE); - } - - public MsgGroupDelayDepA() { - super(TYPE); - } - - public MsgGroupDelayDepA(SBPMessage msg) throws SBPBinaryException { + public MsgGroupDelayDepA (int sender) { super(sender, TYPE); } + public MsgGroupDelayDepA () { super(TYPE); } + public MsgGroupDelayDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgGroupDelayDepA, expected 146, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgGroupDelayDepA, expected 146, actual " + msg.type); } @Override @@ -71,7 +71,7 @@ protected void parse(Parser parser) throws SBPBinaryException { valid = parser.getU8(); tgd = parser.getS16(); isc_l1ca = parser.getS16(); - isc_l2c = parser.getS16(); + isc_l2c = parser.getS16(); } @Override @@ -81,7 +81,7 @@ protected void build(Builder builder) { builder.putU8(valid); builder.putS16(tgd); builder.putS16(isc_l1ca); - builder.putS16(isc_l2c); + builder.putS16(isc_l2c); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgGroupDelayDepB.java b/java/src/com/swiftnav/sbp/observation/MsgGroupDelayDepB.java index 249be097f..0aabc5f60 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgGroupDelayDepB.java +++ b/java/src/com/swiftnav/sbp/observation/MsgGroupDelayDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,59 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_GROUP_DELAY_DEP_B (0x0093). + +/** SBP class for message MSG_GROUP_DELAY_DEP_B (0x0093). * - *

You can have MSG_GROUP_DELAY_DEP_B inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_GROUP_DELAY_DEP_B inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgGroupDelayDepB extends SBPMessage { public static final int TYPE = 0x0093; + /** Data Predict Time of Week */ public GPSTimeSec t_op; - + /** GNSS signal identifier */ public GnssSignalDep sid; - - /** - * bit-field indicating validity of the values, LSB indicating tgd validity etc. 1 = value is - * valid, 0 = value is not valid. - */ + + /** bit-field indicating validity of the values, LSB indicating tgd + * validity etc. 1 = value is valid, 0 = value is not valid. */ public int valid; - + public int tgd; - + public int isc_l1ca; - + public int isc_l2c; + - public MsgGroupDelayDepB(int sender) { - super(sender, TYPE); - } - - public MsgGroupDelayDepB() { - super(TYPE); - } - - public MsgGroupDelayDepB(SBPMessage msg) throws SBPBinaryException { + public MsgGroupDelayDepB (int sender) { super(sender, TYPE); } + public MsgGroupDelayDepB () { super(TYPE); } + public MsgGroupDelayDepB (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgGroupDelayDepB, expected 147, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgGroupDelayDepB, expected 147, actual " + msg.type); } @Override @@ -71,7 +71,7 @@ protected void parse(Parser parser) throws SBPBinaryException { valid = parser.getU8(); tgd = parser.getS16(); isc_l1ca = parser.getS16(); - isc_l2c = parser.getS16(); + isc_l2c = parser.getS16(); } @Override @@ -81,7 +81,7 @@ protected void build(Builder builder) { builder.putU8(valid); builder.putS16(tgd); builder.putS16(isc_l1ca); - builder.putS16(isc_l2c); + builder.putS16(isc_l2c); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgIono.java b/java/src/com/swiftnav/sbp/observation/MsgIono.java index 745b14727..6865b02cf 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgIono.java +++ b/java/src/com/swiftnav/sbp/observation/MsgIono.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,62 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_IONO (0x0090). +/** SBP class for message MSG_IONO (0x0090). * - *

You can have MSG_IONO inherent its fields directly from an inherited SBP object, or construct - * it inline using a dict of its fields. + * You can have MSG_IONO inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The ionospheric parameters which allow the "L1 only" or "L2 only" user to utilize the - * ionospheric model for computation of the ionospheric delay. Please see ICD-GPS-200 (Chapter - * 20.3.3.5.1.7) for more details. - */ + * The ionospheric parameters which allow the "L1 only" or "L2 only" user to + * utilize the ionospheric model for computation of the ionospheric delay. + * Please see ICD-GPS-200 (Chapter 20.3.3.5.1.7) for more details. */ + public class MsgIono extends SBPMessage { public static final int TYPE = 0x0090; + /** Navigation Message Correction Table Validity Time */ public GPSTimeSec t_nmct; - + public double a0; - + public double a1; - + public double a2; - + public double a3; - + public double b0; - + public double b1; - + public double b2; - + public double b3; + - public MsgIono(int sender) { - super(sender, TYPE); - } - - public MsgIono() { - super(TYPE); - } - - public MsgIono(SBPMessage msg) throws SBPBinaryException { + public MsgIono (int sender) { super(sender, TYPE); } + public MsgIono () { super(TYPE); } + public MsgIono (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgIono, expected 144, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgIono, expected 144, actual " + msg.type); } @Override @@ -77,7 +79,7 @@ protected void parse(Parser parser) throws SBPBinaryException { b0 = parser.getDouble(); b1 = parser.getDouble(); b2 = parser.getDouble(); - b3 = parser.getDouble(); + b3 = parser.getDouble(); } @Override @@ -90,7 +92,7 @@ protected void build(Builder builder) { builder.putDouble(b0); builder.putDouble(b1); builder.putDouble(b2); - builder.putDouble(b3); + builder.putDouble(b3); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgObs.java b/java/src/com/swiftnav/sbp/observation/MsgObs.java index 0fd0d1729..cc24cf184 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgObs.java +++ b/java/src/com/swiftnav/sbp/observation/MsgObs.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,65 +9,67 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_OBS (0x004A). +/** SBP class for message MSG_OBS (0x004A). * - *

You can have MSG_OBS inherent its fields directly from an inherited SBP object, or construct - * it inline using a dict of its fields. + * You can have MSG_OBS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The GPS observations message reports all the raw pseudorange and carrier phase observations - * for the satellites being tracked by the device. Carrier phase observation here is represented as - * a 40-bit fixed point number with Q32.8 layout (i.e. 32-bits of whole cycles and 8-bits of - * fractional cycles). The observations are be interoperable with 3rd party receivers and conform - * with typical RTCMv3 GNSS observations. - */ + * The GPS observations message reports all the raw pseudorange and carrier + * phase observations for the satellites being tracked by the device. Carrier + * phase observation here is represented as a 40-bit fixed point number with + * Q32.8 layout (i.e. 32-bits of whole cycles and 8-bits of fractional + * cycles). The observations are be interoperable with 3rd party receivers and + * conform with typical RTCMv3 GNSS observations. */ + public class MsgObs extends SBPMessage { public static final int TYPE = 0x004A; + /** Header of a GPS observation message */ public ObservationHeader header; - - /** Pseudorange and carrier phase observation for a satellite being tracked. */ + + /** Pseudorange and carrier phase observation for a satellite being + * tracked. */ public PackedObsContent[] obs; + - public MsgObs(int sender) { - super(sender, TYPE); - } - - public MsgObs() { - super(TYPE); - } - - public MsgObs(SBPMessage msg) throws SBPBinaryException { + public MsgObs (int sender) { super(sender, TYPE); } + public MsgObs () { super(TYPE); } + public MsgObs (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgObs, expected 74, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgObs, expected 74, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ header = new ObservationHeader().parse(parser); - obs = parser.getArray(PackedObsContent.class); + obs = parser.getArray(PackedObsContent.class); } @Override protected void build(Builder builder) { header.build(builder); - builder.putArray(obs); + builder.putArray(obs); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgObsDepA.java b/java/src/com/swiftnav/sbp/observation/MsgObsDepA.java index 49d2c893d..3a451903e 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgObsDepA.java +++ b/java/src/com/swiftnav/sbp/observation/MsgObsDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_OBS_DEP_A (0x0045). +/** SBP class for message MSG_OBS_DEP_A (0x0045). * - *

You can have MSG_OBS_DEP_A inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_OBS_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgObsDepA extends SBPMessage { public static final int TYPE = 0x0045; + /** Header of a GPS observation message */ public ObservationHeaderDep header; - - /** Pseudorange and carrier phase observation for a satellite being tracked. */ + + /** Pseudorange and carrier phase observation for a satellite being + * tracked. */ public PackedObsContentDepA[] obs; + - public MsgObsDepA(int sender) { - super(sender, TYPE); - } - - public MsgObsDepA() { - super(TYPE); - } - - public MsgObsDepA(SBPMessage msg) throws SBPBinaryException { + public MsgObsDepA (int sender) { super(sender, TYPE); } + public MsgObsDepA () { super(TYPE); } + public MsgObsDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgObsDepA, expected 69, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgObsDepA, expected 69, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ header = new ObservationHeaderDep().parse(parser); - obs = parser.getArray(PackedObsContentDepA.class); + obs = parser.getArray(PackedObsContentDepA.class); } @Override protected void build(Builder builder) { header.build(builder); - builder.putArray(obs); + builder.putArray(obs); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgObsDepB.java b/java/src/com/swiftnav/sbp/observation/MsgObsDepB.java index ace43daa6..f25179736 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgObsDepB.java +++ b/java/src/com/swiftnav/sbp/observation/MsgObsDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_OBS_DEP_B (0x0043). +/** SBP class for message MSG_OBS_DEP_B (0x0043). * - *

You can have MSG_OBS_DEP_B inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_OBS_DEP_B inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgObsDepB extends SBPMessage { public static final int TYPE = 0x0043; + /** Header of a GPS observation message */ public ObservationHeaderDep header; - - /** Pseudorange and carrier phase observation for a satellite being tracked. */ + + /** Pseudorange and carrier phase observation for a satellite being + * tracked. */ public PackedObsContentDepB[] obs; + - public MsgObsDepB(int sender) { - super(sender, TYPE); - } - - public MsgObsDepB() { - super(TYPE); - } - - public MsgObsDepB(SBPMessage msg) throws SBPBinaryException { + public MsgObsDepB (int sender) { super(sender, TYPE); } + public MsgObsDepB () { super(TYPE); } + public MsgObsDepB (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgObsDepB, expected 67, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgObsDepB, expected 67, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ header = new ObservationHeaderDep().parse(parser); - obs = parser.getArray(PackedObsContentDepB.class); + obs = parser.getArray(PackedObsContentDepB.class); } @Override protected void build(Builder builder) { header.build(builder); - builder.putArray(obs); + builder.putArray(obs); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgObsDepC.java b/java/src/com/swiftnav/sbp/observation/MsgObsDepC.java index 866b34fff..242ce02cc 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgObsDepC.java +++ b/java/src/com/swiftnav/sbp/observation/MsgObsDepC.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_OBS_DEP_C (0x0049). +/** SBP class for message MSG_OBS_DEP_C (0x0049). * - *

You can have MSG_OBS_DEP_C inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_OBS_DEP_C inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgObsDepC extends SBPMessage { public static final int TYPE = 0x0049; + /** Header of a GPS observation message */ public ObservationHeaderDep header; - - /** Pseudorange and carrier phase observation for a satellite being tracked. */ + + /** Pseudorange and carrier phase observation for a satellite being + * tracked. */ public PackedObsContentDepC[] obs; + - public MsgObsDepC(int sender) { - super(sender, TYPE); - } - - public MsgObsDepC() { - super(TYPE); - } - - public MsgObsDepC(SBPMessage msg) throws SBPBinaryException { + public MsgObsDepC (int sender) { super(sender, TYPE); } + public MsgObsDepC () { super(TYPE); } + public MsgObsDepC (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgObsDepC, expected 73, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgObsDepC, expected 73, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ header = new ObservationHeaderDep().parse(parser); - obs = parser.getArray(PackedObsContentDepC.class); + obs = parser.getArray(PackedObsContentDepC.class); } @Override protected void build(Builder builder) { header.build(builder); - builder.putArray(obs); + builder.putArray(obs); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgOsr.java b/java/src/com/swiftnav/sbp/observation/MsgOsr.java index a7e9f466c..20e22f2e3 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgOsr.java +++ b/java/src/com/swiftnav/sbp/observation/MsgOsr.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,61 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_OSR (0x0640). +/** SBP class for message MSG_OSR (0x0640). * - *

You can have MSG_OSR inherent its fields directly from an inherited SBP object, or construct - * it inline using a dict of its fields. + * You can have MSG_OSR inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The OSR message contains network corrections in an observation-like format. - */ + * The OSR message contains network corrections in an observation-like format. */ + public class MsgOsr extends SBPMessage { public static final int TYPE = 0x0640; + /** Header of a GPS observation message */ public ObservationHeader header; - + /** Network correction for a satellite signal. */ public PackedOsrContent[] obs; + - public MsgOsr(int sender) { - super(sender, TYPE); - } - - public MsgOsr() { - super(TYPE); - } - - public MsgOsr(SBPMessage msg) throws SBPBinaryException { + public MsgOsr (int sender) { super(sender, TYPE); } + public MsgOsr () { super(TYPE); } + public MsgOsr (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgOsr, expected 1600, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgOsr, expected 1600, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ header = new ObservationHeader().parse(parser); - obs = parser.getArray(PackedOsrContent.class); + obs = parser.getArray(PackedOsrContent.class); } @Override protected void build(Builder builder) { header.build(builder); - builder.putArray(obs); + builder.putArray(obs); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgSvAzEl.java b/java/src/com/swiftnav/sbp/observation/MsgSvAzEl.java index 9ec833027..5b0076c11 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgSvAzEl.java +++ b/java/src/com/swiftnav/sbp/observation/MsgSvAzEl.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,57 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SV_AZ_EL (0x0097). +/** SBP class for message MSG_SV_AZ_EL (0x0097). * - *

You can have MSG_SV_AZ_EL inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_SV_AZ_EL inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Azimuth and elevation angles of all the visible satellites that the device does have ephemeris - * or almanac for. - */ + * Azimuth and elevation angles of all the visible satellites that the device + * does have ephemeris or almanac for. */ + public class MsgSvAzEl extends SBPMessage { public static final int TYPE = 0x0097; + /** Azimuth and elevation per satellite */ public SvAzEl[] azel; + - public MsgSvAzEl(int sender) { - super(sender, TYPE); - } - - public MsgSvAzEl() { - super(TYPE); - } - - public MsgSvAzEl(SBPMessage msg) throws SBPBinaryException { + public MsgSvAzEl (int sender) { super(sender, TYPE); } + public MsgSvAzEl () { super(TYPE); } + public MsgSvAzEl (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSvAzEl, expected 151, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSvAzEl, expected 151, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - azel = parser.getArray(SvAzEl.class); + azel = parser.getArray(SvAzEl.class); } @Override protected void build(Builder builder) { - builder.putArray(azel); + builder.putArray(azel); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/MsgSvConfigurationGPSDep.java b/java/src/com/swiftnav/sbp/observation/MsgSvConfigurationGPSDep.java index aa333ead0..73ff7fdf4 100644 --- a/java/src/com/swiftnav/sbp/observation/MsgSvConfigurationGPSDep.java +++ b/java/src/com/swiftnav/sbp/observation/MsgSvConfigurationGPSDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,61 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SV_CONFIGURATION_GPS_DEP (0x0091). +/** SBP class for message MSG_SV_CONFIGURATION_GPS_DEP (0x0091). * - *

You can have MSG_SV_CONFIGURATION_GPS_DEP inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SV_CONFIGURATION_GPS_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSvConfigurationGPSDep extends SBPMessage { public static final int TYPE = 0x0091; + /** Navigation Message Correction Table Validity Time */ public GPSTimeSec t_nmct; - + /** L2C capability mask, SV32 bit being MSB, SV1 bit being LSB */ public long l2c_mask; + - public MsgSvConfigurationGPSDep(int sender) { - super(sender, TYPE); - } - - public MsgSvConfigurationGPSDep() { - super(TYPE); - } - - public MsgSvConfigurationGPSDep(SBPMessage msg) throws SBPBinaryException { + public MsgSvConfigurationGPSDep (int sender) { super(sender, TYPE); } + public MsgSvConfigurationGPSDep () { super(TYPE); } + public MsgSvConfigurationGPSDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSvConfigurationGPSDep, expected 145, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSvConfigurationGPSDep, expected 145, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ t_nmct = new GPSTimeSec().parse(parser); - l2c_mask = parser.getU32(); + l2c_mask = parser.getU32(); } @Override protected void build(Builder builder) { t_nmct.build(builder); - builder.putU32(l2c_mask); + builder.putU32(l2c_mask); } @Override diff --git a/java/src/com/swiftnav/sbp/observation/ObservationHeader.java b/java/src/com/swiftnav/sbp/observation/ObservationHeader.java index 3700c3dfd..08b0c2f7e 100644 --- a/java/src/com/swiftnav/sbp/observation/ObservationHeader.java +++ b/java/src/com/swiftnav/sbp/observation/ObservationHeader.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,30 +9,33 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class ObservationHeader extends SBPStruct { - + /** GNSS time of this observation */ public GPSTime t; - - /** - * Total number of observations. First nibble is the size of the sequence (n), second nibble is - * the zero-indexed counter (ith packet of n) - */ + + /** Total number of observations. First nibble is the size of the sequence (n), + * second nibble is the zero-indexed counter (ith packet of n) */ public int n_obs; + - public ObservationHeader() {} + public ObservationHeader () {} @Override public ObservationHeader parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/ObservationHeaderDep.java b/java/src/com/swiftnav/sbp/observation/ObservationHeaderDep.java index 0d1609056..52452358c 100644 --- a/java/src/com/swiftnav/sbp/observation/ObservationHeaderDep.java +++ b/java/src/com/swiftnav/sbp/observation/ObservationHeaderDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,30 +9,33 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class ObservationHeaderDep extends SBPStruct { - + /** GPS time of this observation */ public GPSTimeDep t; - - /** - * Total number of observations. First nibble is the size of the sequence (n), second nibble is - * the zero-indexed counter (ith packet of n) - */ + + /** Total number of observations. First nibble is the size of the sequence (n), + * second nibble is the zero-indexed counter (ith packet of n) */ public int n_obs; + - public ObservationHeaderDep() {} + public ObservationHeaderDep () {} @Override public ObservationHeaderDep parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/PackedObsContent.java b/java/src/com/swiftnav/sbp/observation/PackedObsContent.java index adffb389d..70ce3b011 100644 --- a/java/src/com/swiftnav/sbp/observation/PackedObsContent.java +++ b/java/src/com/swiftnav/sbp/observation/PackedObsContent.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,50 +9,53 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class PackedObsContent extends SBPStruct { - + /** Pseudorange observation */ public long P; - + /** Carrier phase observation with typical sign convention. */ public CarrierPhase L; - + /** Doppler observation with typical sign convention. */ public Doppler D; - - /** Carrier-to-Noise density. Zero implies invalid cn0. */ + + /** Carrier-to-Noise density. Zero implies invalid cn0. */ public int cn0; - - /** - * Lock timer. This value gives an indication of the time for which a signal has maintained - * continuous phase lock. Whenever a signal has lost and regained lock, this value is reset to - * zero. It is encoded according to DF402 from the RTCM 10403.2 Amendment 2 specification. Valid - * values range from 0 to 15 and the most significant nibble is reserved for future use. - */ + + /** Lock timer. This value gives an indication of the time for which a signal has + * maintained continuous phase lock. Whenever a signal has lost and regained lock, + * this value is reset to zero. It is encoded according to DF402 from the RTCM + * 10403.2 Amendment 2 specification. Valid values range from 0 to 15 and the + * most significant nibble is reserved for future use. */ public int lock; - - /** - * Measurement status flags. A bit field of flags providing the status of this observation. If - * this field is 0 it means only the Cn0 estimate for the signal is valid. - */ + + /** Measurement status flags. A bit field of flags providing the status of this + * observation. If this field is 0 it means only the Cn0 estimate for the signal + * is valid. */ public int flags; - + /** GNSS signal identifier (16 bit) */ public GnssSignal sid; + - public PackedObsContent() {} + public PackedObsContent () {} @Override public PackedObsContent parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/PackedObsContentDepA.java b/java/src/com/swiftnav/sbp/observation/PackedObsContentDepA.java index 90019c7f4..a1f453255 100644 --- a/java/src/com/swiftnav/sbp/observation/PackedObsContentDepA.java +++ b/java/src/com/swiftnav/sbp/observation/PackedObsContentDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,39 +9,42 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class PackedObsContentDepA extends SBPStruct { - + /** Pseudorange observation */ public long P; - + /** Carrier phase observation with opposite sign from typical convention */ public CarrierPhaseDepA L; - + /** Carrier-to-Noise density */ public int cn0; - - /** - * Lock indicator. This value changes whenever a satellite signal has lost and regained lock, - * indicating that the carrier phase ambiguity may have changed. - */ + + /** Lock indicator. This value changes whenever a satellite signal has lost and + * regained lock, indicating that the carrier phase ambiguity may have changed. */ public int lock; - + /** PRN-1 identifier of the satellite signal */ public int prn; + - public PackedObsContentDepA() {} + public PackedObsContentDepA () {} @Override public PackedObsContentDepA parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/PackedObsContentDepB.java b/java/src/com/swiftnav/sbp/observation/PackedObsContentDepB.java index cb1050c2d..380658b9f 100644 --- a/java/src/com/swiftnav/sbp/observation/PackedObsContentDepB.java +++ b/java/src/com/swiftnav/sbp/observation/PackedObsContentDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,39 +9,42 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class PackedObsContentDepB extends SBPStruct { - + /** Pseudorange observation */ public long P; - + /** Carrier phase observation with opposite sign from typical convention. */ public CarrierPhaseDepA L; - + /** Carrier-to-Noise density */ public int cn0; - - /** - * Lock indicator. This value changes whenever a satellite signal has lost and regained lock, - * indicating that the carrier phase ambiguity may have changed. - */ + + /** Lock indicator. This value changes whenever a satellite signal has lost and + * regained lock, indicating that the carrier phase ambiguity may have changed. */ public int lock; - + /** GNSS signal identifier */ public GnssSignalDep sid; + - public PackedObsContentDepB() {} + public PackedObsContentDepB () {} @Override public PackedObsContentDepB parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/PackedObsContentDepC.java b/java/src/com/swiftnav/sbp/observation/PackedObsContentDepC.java index 80543df58..8282db99f 100644 --- a/java/src/com/swiftnav/sbp/observation/PackedObsContentDepC.java +++ b/java/src/com/swiftnav/sbp/observation/PackedObsContentDepC.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,39 +9,42 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class PackedObsContentDepC extends SBPStruct { - + /** Pseudorange observation */ public long P; - + /** Carrier phase observation with typical sign convention. */ public CarrierPhase L; - + /** Carrier-to-Noise density */ public int cn0; - - /** - * Lock indicator. This value changes whenever a satellite signal has lost and regained lock, - * indicating that the carrier phase ambiguity may have changed. - */ + + /** Lock indicator. This value changes whenever a satellite signal has lost and + * regained lock, indicating that the carrier phase ambiguity may have changed. */ public int lock; - + /** GNSS signal identifier */ public GnssSignalDep sid; + - public PackedObsContentDepC() {} + public PackedObsContentDepC () {} @Override public PackedObsContentDepC parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/PackedOsrContent.java b/java/src/com/swiftnav/sbp/observation/PackedOsrContent.java index 8a964e761..3a3a6715b 100644 --- a/java/src/com/swiftnav/sbp/observation/PackedOsrContent.java +++ b/java/src/com/swiftnav/sbp/observation/PackedOsrContent.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,50 +9,54 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class PackedOsrContent extends SBPStruct { - + /** Pseudorange observation */ public long P; - + /** Carrier phase observation with typical sign convention. */ public CarrierPhase L; - - /** - * Lock timer. This value gives an indication of the time for which a signal has maintained - * continuous phase lock. Whenever a signal has lost and regained lock, this value is reset to - * zero. It is encoded according to DF402 from the RTCM 10403.2 Amendment 2 specification. Valid - * values range from 0 to 15 and the most significant nibble is reserved for future use. - */ + + /** Lock timer. This value gives an indication of the time for which a signal has + * maintained continuous phase lock. Whenever a signal has lost and regained lock, + * this value is reset to zero. It is encoded according to DF402 from the RTCM + * 10403.2 Amendment 2 specification. Valid values range from 0 to 15 and the + * most significant nibble is reserved for future use. */ public int lock; - + /** Correction flags. */ public int flags; - + /** GNSS signal identifier (16 bit) */ public GnssSignal sid; - + /** Slant ionospheric correction standard deviation */ public int iono_std; - + /** Slant tropospheric correction standard deviation */ public int tropo_std; - + /** Orbit/clock/bias correction projected on range standard deviation */ public int range_std; + - public PackedOsrContent() {} + public PackedOsrContent () {} @Override public PackedOsrContent parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/observation/SvAzEl.java b/java/src/com/swiftnav/sbp/observation/SvAzEl.java index 41b0d3dad..5db524ee5 100644 --- a/java/src/com/swiftnav/sbp/observation/SvAzEl.java +++ b/java/src/com/swiftnav/sbp/observation/SvAzEl.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,30 +9,35 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.observation; // This file was auto-generated from yaml/swiftnav/sbp/observation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class SvAzEl extends SBPStruct { - + /** GNSS signal identifier */ public GnssSignal sid; - + /** Azimuth angle (range 0..179) */ public int az; - + /** Elevation angle (range -90..90) */ public int el; + - public SvAzEl() {} + public SvAzEl () {} @Override public SvAzEl parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/orientation/MsgAngularRate.java b/java/src/com/swiftnav/sbp/orientation/MsgAngularRate.java index 418899bd8..5fb67b41a 100644 --- a/java/src/com/swiftnav/sbp/orientation/MsgAngularRate.java +++ b/java/src/com/swiftnav/sbp/orientation/MsgAngularRate.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,64 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.orientation; // This file was auto-generated from yaml/swiftnav/sbp/orientation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_ANGULAR_RATE (0x0222). + +/** SBP class for message MSG_ANGULAR_RATE (0x0222). * - *

You can have MSG_ANGULAR_RATE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_ANGULAR_RATE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the orientation rates in the vehicle body frame. The values represent the - * measurements a strapped down gyroscope would make and are not equivalent to the time derivative - * of the Euler angles. The orientation and origin of the user frame is specified via device - * settings. By convention, the vehicle x-axis is expected to be aligned with the forward direction, - * while the vehicle y-axis is expected to be aligned with the right direction, and the vehicle - * z-axis should be aligned with the down direction. This message will only be available in future - * INS versions of Swift Products and is not produced by Piksi Multi or Duro. - */ + * This message reports the orientation rates in the vehicle body frame. The + * values represent the measurements a strapped down gyroscope would make and + * are not equivalent to the time derivative of the Euler angles. The + * orientation and origin of the user frame is specified via device settings. + * By convention, the vehicle x-axis is expected to be aligned with the + * forward direction, while the vehicle y-axis is expected to be aligned with + * the right direction, and the vehicle z-axis should be aligned with the down + * direction. This message will only be available in future INS versions of + * Swift Products and is not produced by Piksi Multi or Duro. */ + public class MsgAngularRate extends SBPMessage { public static final int TYPE = 0x0222; + /** GPS Time of Week */ public long tow; - + /** angular rate about x axis */ public int x; - + /** angular rate about y axis */ public int y; - + /** angular rate about z axis */ public int z; - + /** Status flags */ public int flags; + - public MsgAngularRate(int sender) { - super(sender, TYPE); - } - - public MsgAngularRate() { - super(TYPE); - } - - public MsgAngularRate(SBPMessage msg) throws SBPBinaryException { + public MsgAngularRate (int sender) { super(sender, TYPE); } + public MsgAngularRate () { super(TYPE); } + public MsgAngularRate (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAngularRate, expected 546, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAngularRate, expected 546, actual " + msg.type); } @Override @@ -72,7 +76,7 @@ protected void parse(Parser parser) throws SBPBinaryException { x = parser.getS32(); y = parser.getS32(); z = parser.getS32(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -81,7 +85,7 @@ protected void build(Builder builder) { builder.putS32(x); builder.putS32(y); builder.putS32(z); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/orientation/MsgBaselineHeading.java b/java/src/com/swiftnav/sbp/orientation/MsgBaselineHeading.java index 64b70b9c7..ab80dfb1f 100644 --- a/java/src/com/swiftnav/sbp/orientation/MsgBaselineHeading.java +++ b/java/src/com/swiftnav/sbp/orientation/MsgBaselineHeading.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.orientation; // This file was auto-generated from yaml/swiftnav/sbp/orientation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_BASELINE_HEADING (0x020F). + +/** SBP class for message MSG_BASELINE_HEADING (0x020F). * - *

You can have MSG_BASELINE_HEADING inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_BASELINE_HEADING inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the baseline heading pointing from the base station to the rover relative - * to True North. The full GPS time is given by the preceding MSG_GPS_TIME with the matching - * time-of-week (tow). It is intended that time-matched RTK mode is used when the base station is - * moving. - */ + * This message reports the baseline heading pointing from the base station to + * the rover relative to True North. The full GPS time is given by the + * preceding MSG_GPS_TIME with the matching time-of-week (tow). It is intended + * that time-matched RTK mode is used when the base station is moving. */ + public class MsgBaselineHeading extends SBPMessage { public static final int TYPE = 0x020F; + /** GPS Time of Week */ public long tow; - + /** Heading */ public long heading; - + /** Number of satellites used in solution */ public int n_sats; - + /** Status flags */ public int flags; + - public MsgBaselineHeading(int sender) { - super(sender, TYPE); - } - - public MsgBaselineHeading() { - super(TYPE); - } - - public MsgBaselineHeading(SBPMessage msg) throws SBPBinaryException { + public MsgBaselineHeading (int sender) { super(sender, TYPE); } + public MsgBaselineHeading () { super(TYPE); } + public MsgBaselineHeading (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgBaselineHeading, expected 527, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgBaselineHeading, expected 527, actual " + msg.type); } @Override @@ -65,7 +67,7 @@ protected void parse(Parser parser) throws SBPBinaryException { tow = parser.getU32(); heading = parser.getU32(); n_sats = parser.getU8(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -73,7 +75,7 @@ protected void build(Builder builder) { builder.putU32(tow); builder.putU32(heading); builder.putU8(n_sats); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/orientation/MsgOrientEuler.java b/java/src/com/swiftnav/sbp/orientation/MsgOrientEuler.java index e47a5eddc..37844bc56 100644 --- a/java/src/com/swiftnav/sbp/orientation/MsgOrientEuler.java +++ b/java/src/com/swiftnav/sbp/orientation/MsgOrientEuler.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,67 +9,70 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.orientation; // This file was auto-generated from yaml/swiftnav/sbp/orientation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ORIENT_EULER (0x0221). +/** SBP class for message MSG_ORIENT_EULER (0x0221). * - *

You can have MSG_ORIENT_EULER inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_ORIENT_EULER inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the yaw, pitch, and roll angles of the vehicle body frame. The rotations - * should applied intrinsically in the order yaw, pitch, and roll in order to rotate the from a - * frame aligned with the local-level NED frame to the vehicle body frame. This message will only be - * available in future INS versions of Swift Products and is not produced by Piksi Multi or Duro. - */ + * This message reports the yaw, pitch, and roll angles of the vehicle body + * frame. The rotations should applied intrinsically in the order yaw, pitch, + * and roll in order to rotate the from a frame aligned with the local-level + * NED frame to the vehicle body frame. This message will only be available + * in future INS versions of Swift Products and is not produced by Piksi Multi + * or Duro. */ + public class MsgOrientEuler extends SBPMessage { public static final int TYPE = 0x0221; + /** GPS Time of Week */ public long tow; - + /** rotation about the forward axis of the vehicle */ public int roll; - + /** rotation about the rightward axis of the vehicle */ public int pitch; - + /** rotation about the downward axis of the vehicle */ public int yaw; - + /** Estimated standard deviation of roll */ public float roll_accuracy; - + /** Estimated standard deviation of pitch */ public float pitch_accuracy; - + /** Estimated standard deviation of yaw */ public float yaw_accuracy; - + /** Status flags */ public int flags; + - public MsgOrientEuler(int sender) { - super(sender, TYPE); - } - - public MsgOrientEuler() { - super(TYPE); - } - - public MsgOrientEuler(SBPMessage msg) throws SBPBinaryException { + public MsgOrientEuler (int sender) { super(sender, TYPE); } + public MsgOrientEuler () { super(TYPE); } + public MsgOrientEuler (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgOrientEuler, expected 545, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgOrientEuler, expected 545, actual " + msg.type); } @Override @@ -81,7 +85,7 @@ protected void parse(Parser parser) throws SBPBinaryException { roll_accuracy = parser.getFloat(); pitch_accuracy = parser.getFloat(); yaw_accuracy = parser.getFloat(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -93,7 +97,7 @@ protected void build(Builder builder) { builder.putFloat(roll_accuracy); builder.putFloat(pitch_accuracy); builder.putFloat(yaw_accuracy); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/orientation/MsgOrientQuat.java b/java/src/com/swiftnav/sbp/orientation/MsgOrientQuat.java index e1894b558..f76b69839 100644 --- a/java/src/com/swiftnav/sbp/orientation/MsgOrientQuat.java +++ b/java/src/com/swiftnav/sbp/orientation/MsgOrientQuat.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,73 +9,76 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.orientation; // This file was auto-generated from yaml/swiftnav/sbp/orientation.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ORIENT_QUAT (0x0220). +/** SBP class for message MSG_ORIENT_QUAT (0x0220). * - *

You can have MSG_ORIENT_QUAT inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_ORIENT_QUAT inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the quaternion vector describing the vehicle body frame's orientation - * with respect to a local-level NED frame. The components of the vector should sum to a unit vector - * assuming that the LSB of each component as a value of 2^-31. This message will only be available - * in future INS versions of Swift Products and is not produced by Piksi Multi or Duro. - */ + * This message reports the quaternion vector describing the vehicle body + * frame's orientation with respect to a local-level NED frame. The components + * of the vector should sum to a unit vector assuming that the LSB of each + * component as a value of 2^-31. This message will only be available in + * future INS versions of Swift Products and is not produced by Piksi Multi or + * Duro. */ + public class MsgOrientQuat extends SBPMessage { public static final int TYPE = 0x0220; + /** GPS Time of Week */ public long tow; - + /** Real component */ public int w; - + /** 1st imaginary component */ public int x; - + /** 2nd imaginary component */ public int y; - + /** 3rd imaginary component */ public int z; - + /** Estimated standard deviation of w */ public float w_accuracy; - + /** Estimated standard deviation of x */ public float x_accuracy; - + /** Estimated standard deviation of y */ public float y_accuracy; - + /** Estimated standard deviation of z */ public float z_accuracy; - + /** Status flags */ public int flags; + - public MsgOrientQuat(int sender) { - super(sender, TYPE); - } - - public MsgOrientQuat() { - super(TYPE); - } - - public MsgOrientQuat(SBPMessage msg) throws SBPBinaryException { + public MsgOrientQuat (int sender) { super(sender, TYPE); } + public MsgOrientQuat () { super(TYPE); } + public MsgOrientQuat (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgOrientQuat, expected 544, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgOrientQuat, expected 544, actual " + msg.type); } @Override @@ -89,7 +93,7 @@ protected void parse(Parser parser) throws SBPBinaryException { x_accuracy = parser.getFloat(); y_accuracy = parser.getFloat(); z_accuracy = parser.getFloat(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -103,7 +107,7 @@ protected void build(Builder builder) { builder.putFloat(x_accuracy); builder.putFloat(y_accuracy); builder.putFloat(z_accuracy); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/Latency.java b/java/src/com/swiftnav/sbp/piksi/Latency.java index 6e43319b1..1dd9a26c9 100644 --- a/java/src/com/swiftnav/sbp/piksi/Latency.java +++ b/java/src/com/swiftnav/sbp/piksi/Latency.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,33 +9,38 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class Latency extends SBPStruct { - + /** Average latency */ public int avg; - + /** Minimum latency */ public int lmin; - + /** Maximum latency */ public int lmax; - + /** Smoothed estimate of the current latency */ public int current; + - public Latency() {} + public Latency () {} @Override public Latency parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/piksi/MsgAlmanac.java b/java/src/com/swiftnav/sbp/piksi/MsgAlmanac.java index 08791318c..b1cd72d5b 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgAlmanac.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgAlmanac.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,42 +9,43 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ALMANAC (0x0069). +/** SBP class for message MSG_ALMANAC (0x0069). * - *

You can have MSG_ALMANAC inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_ALMANAC inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This is a legacy message for sending and loading a satellite alamanac onto the Piksi's flash - * memory from the host. - */ + * This is a legacy message for sending and loading a satellite alamanac onto + * the Piksi's flash memory from the host. */ + public class MsgAlmanac extends SBPMessage { public static final int TYPE = 0x0069; - public MsgAlmanac(int sender) { - super(sender, TYPE); - } - - public MsgAlmanac() { - super(TYPE); - } + - public MsgAlmanac(SBPMessage msg) throws SBPBinaryException { + public MsgAlmanac (int sender) { super(sender, TYPE); } + public MsgAlmanac () { super(TYPE); } + public MsgAlmanac (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAlmanac, expected 105, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAlmanac, expected 105, actual " + msg.type); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgCellModemStatus.java b/java/src/com/swiftnav/sbp/piksi/MsgCellModemStatus.java index a3004620a..0d045d2ef 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgCellModemStatus.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgCellModemStatus.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,52 +9,53 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_CELL_MODEM_STATUS (0x00BE). + +/** SBP class for message MSG_CELL_MODEM_STATUS (0x00BE). * - *

You can have MSG_CELL_MODEM_STATUS inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_CELL_MODEM_STATUS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

If a cell modem is present on a piksi device, this message will be send periodically to update - * the host on the status of the modem and its various parameters. - */ + * If a cell modem is present on a piksi device, this message will be send + * periodically to update the host on the status of the modem and its various + * parameters. */ + public class MsgCellModemStatus extends SBPMessage { public static final int TYPE = 0x00BE; + /** Received cell signal strength in dBm, zero translates to unknown */ public int signal_strength; - + /** BER as reported by the modem, zero translates to unknown */ public float signal_error_rate; - + /** Unspecified data TBD for this schema */ public int[] reserved; + - public MsgCellModemStatus(int sender) { - super(sender, TYPE); - } - - public MsgCellModemStatus() { - super(TYPE); - } - - public MsgCellModemStatus(SBPMessage msg) throws SBPBinaryException { + public MsgCellModemStatus (int sender) { super(sender, TYPE); } + public MsgCellModemStatus () { super(TYPE); } + public MsgCellModemStatus (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgCellModemStatus, expected 190, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgCellModemStatus, expected 190, actual " + msg.type); } @Override @@ -61,14 +63,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ signal_strength = parser.getS8(); signal_error_rate = parser.getFloat(); - reserved = parser.getArrayofU8(); + reserved = parser.getArrayofU8(); } @Override protected void build(Builder builder) { builder.putS8(signal_strength); builder.putFloat(signal_error_rate); - builder.putArrayofU8(reserved); + builder.putArrayofU8(reserved); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgCommandOutput.java b/java/src/com/swiftnav/sbp/piksi/MsgCommandOutput.java index 55c18f7b0..7d2cd3bec 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgCommandOutput.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgCommandOutput.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_COMMAND_OUTPUT (0x00BC). +/** SBP class for message MSG_COMMAND_OUTPUT (0x00BC). * - *

You can have MSG_COMMAND_OUTPUT inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_COMMAND_OUTPUT inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Returns the standard output and standard error of the command requested by MSG_COMMAND_REQ. - * The sequence number can be used to filter for filtering the correct command. - */ + * Returns the standard output and standard error of the command requested by + * MSG_COMMAND_REQ. The sequence number can be used to filter for filtering + * the correct command. */ + public class MsgCommandOutput extends SBPMessage { public static final int TYPE = 0x00BC; + /** Sequence number */ public long sequence; - + /** Line of standard output or standard error */ public String line; + - public MsgCommandOutput(int sender) { - super(sender, TYPE); - } - - public MsgCommandOutput() { - super(TYPE); - } - - public MsgCommandOutput(SBPMessage msg) throws SBPBinaryException { + public MsgCommandOutput (int sender) { super(sender, TYPE); } + public MsgCommandOutput () { super(TYPE); } + public MsgCommandOutput (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgCommandOutput, expected 188, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgCommandOutput, expected 188, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ sequence = parser.getU32(); - line = parser.getString(); + line = parser.getString(); } @Override protected void build(Builder builder) { builder.putU32(sequence); - builder.putString(line); + builder.putString(line); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgCommandReq.java b/java/src/com/swiftnav/sbp/piksi/MsgCommandReq.java index fcf9e0adf..5d983ce71 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgCommandReq.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgCommandReq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_COMMAND_REQ (0x00B8). +/** SBP class for message MSG_COMMAND_REQ (0x00B8). * - *

You can have MSG_COMMAND_REQ inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_COMMAND_REQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Request the recipient to execute an command. Output will be sent in MSG_LOG messages, and the - * exit code will be returned with MSG_COMMAND_RESP. - */ + * Request the recipient to execute an command. Output will be sent in MSG_LOG + * messages, and the exit code will be returned with MSG_COMMAND_RESP. */ + public class MsgCommandReq extends SBPMessage { public static final int TYPE = 0x00B8; + /** Sequence number */ public long sequence; - + /** Command line to execute */ public String command; + - public MsgCommandReq(int sender) { - super(sender, TYPE); - } - - public MsgCommandReq() { - super(TYPE); - } - - public MsgCommandReq(SBPMessage msg) throws SBPBinaryException { + public MsgCommandReq (int sender) { super(sender, TYPE); } + public MsgCommandReq () { super(TYPE); } + public MsgCommandReq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgCommandReq, expected 184, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgCommandReq, expected 184, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ sequence = parser.getU32(); - command = parser.getString(); + command = parser.getString(); } @Override protected void build(Builder builder) { builder.putU32(sequence); - builder.putString(command); + builder.putString(command); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgCommandResp.java b/java/src/com/swiftnav/sbp/piksi/MsgCommandResp.java index 032ae3708..e9447aef0 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgCommandResp.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgCommandResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_COMMAND_RESP (0x00B9). +/** SBP class for message MSG_COMMAND_RESP (0x00B9). * - *

You can have MSG_COMMAND_RESP inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_COMMAND_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The response to MSG_COMMAND_REQ with the return code of the command. A return code of zero - * indicates success. - */ + * The response to MSG_COMMAND_REQ with the return code of the command. A + * return code of zero indicates success. */ + public class MsgCommandResp extends SBPMessage { public static final int TYPE = 0x00B9; + /** Sequence number */ public long sequence; - + /** Exit code */ public int code; + - public MsgCommandResp(int sender) { - super(sender, TYPE); - } - - public MsgCommandResp() { - super(TYPE); - } - - public MsgCommandResp(SBPMessage msg) throws SBPBinaryException { + public MsgCommandResp (int sender) { super(sender, TYPE); } + public MsgCommandResp () { super(TYPE); } + public MsgCommandResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgCommandResp, expected 185, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgCommandResp, expected 185, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ sequence = parser.getU32(); - code = parser.getS32(); + code = parser.getS32(); } @Override protected void build(Builder builder) { builder.putU32(sequence); - builder.putS32(code); + builder.putS32(code); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgCwResults.java b/java/src/com/swiftnav/sbp/piksi/MsgCwResults.java index a8ea0b8c3..c7dfd1940 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgCwResults.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgCwResults.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,42 +9,44 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_CW_RESULTS (0x00C0). +/** SBP class for message MSG_CW_RESULTS (0x00C0). * - *

You can have MSG_CW_RESULTS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_CW_RESULTS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This is an unused legacy message for result reporting from the CW interference channel on the - * SwiftNAP. This message will be removed in a future release. - */ + * This is an unused legacy message for result reporting from the CW + * interference channel on the SwiftNAP. This message will be removed in a + * future release. */ + public class MsgCwResults extends SBPMessage { public static final int TYPE = 0x00C0; - public MsgCwResults(int sender) { - super(sender, TYPE); - } - - public MsgCwResults() { - super(TYPE); - } + - public MsgCwResults(SBPMessage msg) throws SBPBinaryException { + public MsgCwResults (int sender) { super(sender, TYPE); } + public MsgCwResults () { super(TYPE); } + public MsgCwResults (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgCwResults, expected 192, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgCwResults, expected 192, actual " + msg.type); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgCwStart.java b/java/src/com/swiftnav/sbp/piksi/MsgCwStart.java index 47d5db4d1..444796e61 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgCwStart.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgCwStart.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,42 +9,44 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_CW_START (0x00C1). +/** SBP class for message MSG_CW_START (0x00C1). * - *

You can have MSG_CW_START inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_CW_START inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This is an unused legacy message from the host for starting the CW interference channel on the - * SwiftNAP. This message will be removed in a future release. - */ + * This is an unused legacy message from the host for starting the CW + * interference channel on the SwiftNAP. This message will be removed in a + * future release. */ + public class MsgCwStart extends SBPMessage { public static final int TYPE = 0x00C1; - public MsgCwStart(int sender) { - super(sender, TYPE); - } - - public MsgCwStart() { - super(TYPE); - } + - public MsgCwStart(SBPMessage msg) throws SBPBinaryException { + public MsgCwStart (int sender) { super(sender, TYPE); } + public MsgCwStart () { super(TYPE); } + public MsgCwStart (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgCwStart, expected 193, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgCwStart, expected 193, actual " + msg.type); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgDeviceMonitor.java b/java/src/com/swiftnav/sbp/piksi/MsgDeviceMonitor.java index e702dfccb..96ea31307 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgDeviceMonitor.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgDeviceMonitor.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,59 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_DEVICE_MONITOR (0x00B5). + +/** SBP class for message MSG_DEVICE_MONITOR (0x00B5). * - *

You can have MSG_DEVICE_MONITOR inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_DEVICE_MONITOR inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message contains temperature and voltage level measurements from the processor's - * monitoring system and the RF frontend die temperature if available. - */ + * This message contains temperature and voltage level measurements from the + * processor's monitoring system and the RF frontend die temperature if + * available. */ + public class MsgDeviceMonitor extends SBPMessage { public static final int TYPE = 0x00B5; + /** Device V_in */ public int dev_vin; - + /** Processor V_int */ public int cpu_vint; - + /** Processor V_aux */ public int cpu_vaux; - + /** Processor temperature */ public int cpu_temperature; - + /** Frontend temperature (if available) */ public int fe_temperature; + - public MsgDeviceMonitor(int sender) { - super(sender, TYPE); - } - - public MsgDeviceMonitor() { - super(TYPE); - } - - public MsgDeviceMonitor(SBPMessage msg) throws SBPBinaryException { + public MsgDeviceMonitor (int sender) { super(sender, TYPE); } + public MsgDeviceMonitor () { super(TYPE); } + public MsgDeviceMonitor (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgDeviceMonitor, expected 181, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgDeviceMonitor, expected 181, actual " + msg.type); } @Override @@ -68,7 +71,7 @@ protected void parse(Parser parser) throws SBPBinaryException { cpu_vint = parser.getS16(); cpu_vaux = parser.getS16(); cpu_temperature = parser.getS16(); - fe_temperature = parser.getS16(); + fe_temperature = parser.getS16(); } @Override @@ -77,7 +80,7 @@ protected void build(Builder builder) { builder.putS16(cpu_vint); builder.putS16(cpu_vaux); builder.putS16(cpu_temperature); - builder.putS16(fe_temperature); + builder.putS16(fe_temperature); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgFrontEndGain.java b/java/src/com/swiftnav/sbp/piksi/MsgFrontEndGain.java index 8ad1f0f76..b83a8f13b 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgFrontEndGain.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgFrontEndGain.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,66 +9,67 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_FRONT_END_GAIN (0x00BF). +/** SBP class for message MSG_FRONT_END_GAIN (0x00BF). * - *

You can have MSG_FRONT_END_GAIN inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_FRONT_END_GAIN inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message describes the gain of each channel in the receiver frontend. Each gain is encoded - * as a non-dimensional percentage relative to the maximum range possible for the gain stage of the - * frontend. By convention, each gain array has 8 entries and the index of the array corresponding - * to the index of the rf channel in the frontend. A gain of 127 percent encodes that rf channel is - * not present in the hardware. A negative value implies an error for the particular gain stage as - * reported by the frontend. - */ + * This message describes the gain of each channel in the receiver frontend. + * Each gain is encoded as a non-dimensional percentage relative to the + * maximum range possible for the gain stage of the frontend. By convention, + * each gain array has 8 entries and the index of the array corresponding to + * the index of the rf channel in the frontend. A gain of 127 percent encodes + * that rf channel is not present in the hardware. A negative value implies an + * error for the particular gain stage as reported by the frontend. */ + public class MsgFrontEndGain extends SBPMessage { public static final int TYPE = 0x00BF; + /** RF gain for each frontend channel */ public int[] rf_gain; - + /** Intermediate frequency gain for each frontend channel */ public int[] if_gain; + - public MsgFrontEndGain(int sender) { - super(sender, TYPE); - } - - public MsgFrontEndGain() { - super(TYPE); - } - - public MsgFrontEndGain(SBPMessage msg) throws SBPBinaryException { + public MsgFrontEndGain (int sender) { super(sender, TYPE); } + public MsgFrontEndGain () { super(TYPE); } + public MsgFrontEndGain (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgFrontEndGain, expected 191, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgFrontEndGain, expected 191, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ rf_gain = parser.getArrayofS8(8); - if_gain = parser.getArrayofS8(8); + if_gain = parser.getArrayofS8(8); } @Override protected void build(Builder builder) { builder.putArrayofS8(rf_gain, 8); - builder.putArrayofS8(if_gain, 8); + builder.putArrayofS8(if_gain, 8); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgIarState.java b/java/src/com/swiftnav/sbp/piksi/MsgIarState.java index a28cfc283..5fb9b2550 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgIarState.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgIarState.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_IAR_STATE (0x0019). +/** SBP class for message MSG_IAR_STATE (0x0019). * - *

You can have MSG_IAR_STATE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_IAR_STATE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message reports the state of the Integer Ambiguity Resolution (IAR) process, which - * resolves unknown integer ambiguities from double-differenced carrier-phase measurements from - * satellite observations. - */ + * This message reports the state of the Integer Ambiguity Resolution (IAR) + * process, which resolves unknown integer ambiguities from double-differenced + * carrier-phase measurements from satellite observations. */ + public class MsgIarState extends SBPMessage { public static final int TYPE = 0x0019; + /** Number of integer ambiguity hypotheses remaining */ public long num_hyps; + - public MsgIarState(int sender) { - super(sender, TYPE); - } - - public MsgIarState() { - super(TYPE); - } - - public MsgIarState(SBPMessage msg) throws SBPBinaryException { + public MsgIarState (int sender) { super(sender, TYPE); } + public MsgIarState () { super(TYPE); } + public MsgIarState (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgIarState, expected 25, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgIarState, expected 25, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - num_hyps = parser.getU32(); + num_hyps = parser.getU32(); } @Override protected void build(Builder builder) { - builder.putU32(num_hyps); + builder.putU32(num_hyps); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgInitBaseDep.java b/java/src/com/swiftnav/sbp/piksi/MsgInitBaseDep.java index 3b7c99d43..c910d4cf1 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgInitBaseDep.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgInitBaseDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,41 +9,42 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_INIT_BASE_DEP (0x0023). +/** SBP class for message MSG_INIT_BASE_DEP (0x0023). * - *

You can have MSG_INIT_BASE_DEP inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_INIT_BASE_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgInitBaseDep extends SBPMessage { public static final int TYPE = 0x0023; - public MsgInitBaseDep(int sender) { - super(sender, TYPE); - } - - public MsgInitBaseDep() { - super(TYPE); - } + - public MsgInitBaseDep(SBPMessage msg) throws SBPBinaryException { + public MsgInitBaseDep (int sender) { super(sender, TYPE); } + public MsgInitBaseDep () { super(TYPE); } + public MsgInitBaseDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgInitBaseDep, expected 35, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgInitBaseDep, expected 35, actual " + msg.type); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgMaskSatellite.java b/java/src/com/swiftnav/sbp/piksi/MsgMaskSatellite.java index b7063690f..1d0b369b6 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgMaskSatellite.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgMaskSatellite.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_MASK_SATELLITE (0x002B). +/** SBP class for message MSG_MASK_SATELLITE (0x002B). * - *

You can have MSG_MASK_SATELLITE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_MASK_SATELLITE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message allows setting a mask to prevent a particular satellite from being used in - * various Piksi subsystems. - */ + * This message allows setting a mask to prevent a particular satellite from + * being used in various Piksi subsystems. */ + public class MsgMaskSatellite extends SBPMessage { public static final int TYPE = 0x002B; + /** Mask of systems that should ignore this satellite. */ public int mask; - + /** GNSS signal for which the mask is applied */ public GnssSignal sid; + - public MsgMaskSatellite(int sender) { - super(sender, TYPE); - } - - public MsgMaskSatellite() { - super(TYPE); - } - - public MsgMaskSatellite(SBPMessage msg) throws SBPBinaryException { + public MsgMaskSatellite (int sender) { super(sender, TYPE); } + public MsgMaskSatellite () { super(TYPE); } + public MsgMaskSatellite (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgMaskSatellite, expected 43, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgMaskSatellite, expected 43, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ mask = parser.getU8(); - sid = new GnssSignal().parse(parser); + sid = new GnssSignal().parse(parser); } @Override protected void build(Builder builder) { builder.putU8(mask); - sid.build(builder); + sid.build(builder); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgMaskSatelliteDep.java b/java/src/com/swiftnav/sbp/piksi/MsgMaskSatelliteDep.java index 9ba913176..1a946cab4 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgMaskSatelliteDep.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgMaskSatelliteDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,61 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_MASK_SATELLITE_DEP (0x001B). +/** SBP class for message MSG_MASK_SATELLITE_DEP (0x001B). * - *

You can have MSG_MASK_SATELLITE_DEP inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_MASK_SATELLITE_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgMaskSatelliteDep extends SBPMessage { public static final int TYPE = 0x001B; + /** Mask of systems that should ignore this satellite. */ public int mask; - + /** GNSS signal for which the mask is applied */ public GnssSignalDep sid; + - public MsgMaskSatelliteDep(int sender) { - super(sender, TYPE); - } - - public MsgMaskSatelliteDep() { - super(TYPE); - } - - public MsgMaskSatelliteDep(SBPMessage msg) throws SBPBinaryException { + public MsgMaskSatelliteDep (int sender) { super(sender, TYPE); } + public MsgMaskSatelliteDep () { super(TYPE); } + public MsgMaskSatelliteDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgMaskSatelliteDep, expected 27, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgMaskSatelliteDep, expected 27, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ mask = parser.getU8(); - sid = new GnssSignalDep().parse(parser); + sid = new GnssSignalDep().parse(parser); } @Override protected void build(Builder builder) { builder.putU8(mask); - sid.build(builder); + sid.build(builder); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgNetworkBandwidthUsage.java b/java/src/com/swiftnav/sbp/piksi/MsgNetworkBandwidthUsage.java index 21f4782f8..9fc116623 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgNetworkBandwidthUsage.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgNetworkBandwidthUsage.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_NETWORK_BANDWIDTH_USAGE (0x00BD). +/** SBP class for message MSG_NETWORK_BANDWIDTH_USAGE (0x00BD). * - *

You can have MSG_NETWORK_BANDWIDTH_USAGE inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_NETWORK_BANDWIDTH_USAGE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The bandwidth usage, a list of usage by interface. - */ + * The bandwidth usage, a list of usage by interface. */ + public class MsgNetworkBandwidthUsage extends SBPMessage { public static final int TYPE = 0x00BD; + /** Usage measurement array */ public NetworkUsage[] interfaces; + - public MsgNetworkBandwidthUsage(int sender) { - super(sender, TYPE); - } - - public MsgNetworkBandwidthUsage() { - super(TYPE); - } - - public MsgNetworkBandwidthUsage(SBPMessage msg) throws SBPBinaryException { + public MsgNetworkBandwidthUsage (int sender) { super(sender, TYPE); } + public MsgNetworkBandwidthUsage () { super(TYPE); } + public MsgNetworkBandwidthUsage (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgNetworkBandwidthUsage, expected 189, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgNetworkBandwidthUsage, expected 189, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - interfaces = parser.getArray(NetworkUsage.class); + interfaces = parser.getArray(NetworkUsage.class); } @Override protected void build(Builder builder) { - builder.putArray(interfaces); + builder.putArray(interfaces); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgNetworkStateReq.java b/java/src/com/swiftnav/sbp/piksi/MsgNetworkStateReq.java index 1845f386a..9276aebbe 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgNetworkStateReq.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgNetworkStateReq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,42 +9,43 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_NETWORK_STATE_REQ (0x00BA). +/** SBP class for message MSG_NETWORK_STATE_REQ (0x00BA). * - *

You can have MSG_NETWORK_STATE_REQ inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_NETWORK_STATE_REQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Request state of Piksi network interfaces. Output will be sent in MSG_NETWORK_STATE_RESP - * messages. - */ + * Request state of Piksi network interfaces. Output will be sent in + * MSG_NETWORK_STATE_RESP messages. */ + public class MsgNetworkStateReq extends SBPMessage { public static final int TYPE = 0x00BA; - public MsgNetworkStateReq(int sender) { - super(sender, TYPE); - } - - public MsgNetworkStateReq() { - super(TYPE); - } + - public MsgNetworkStateReq(SBPMessage msg) throws SBPBinaryException { + public MsgNetworkStateReq (int sender) { super(sender, TYPE); } + public MsgNetworkStateReq () { super(TYPE); } + public MsgNetworkStateReq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgNetworkStateReq, expected 186, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgNetworkStateReq, expected 186, actual " + msg.type); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgNetworkStateResp.java b/java/src/com/swiftnav/sbp/piksi/MsgNetworkStateResp.java index e2e169222..499cf4526 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgNetworkStateResp.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgNetworkStateResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,67 +9,67 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_NETWORK_STATE_RESP (0x00BB). +/** SBP class for message MSG_NETWORK_STATE_RESP (0x00BB). * - *

You can have MSG_NETWORK_STATE_RESP inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_NETWORK_STATE_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The state of a network interface on the Piksi. Data is made to reflect output of ifaddrs - * struct returned by getifaddrs in c. - */ + * The state of a network interface on the Piksi. Data is made to reflect + * output of ifaddrs struct returned by getifaddrs in c. */ + public class MsgNetworkStateResp extends SBPMessage { public static final int TYPE = 0x00BB; + /** IPv4 address (all zero when unavailable) */ public int[] ipv4_address; - + /** IPv4 netmask CIDR notation */ public int ipv4_mask_size; - + /** IPv6 address (all zero when unavailable) */ public int[] ipv6_address; - + /** IPv6 netmask CIDR notation */ public int ipv6_mask_size; - + /** Number of Rx bytes */ public long rx_bytes; - + /** Number of Tx bytes */ public long tx_bytes; - + /** Interface Name */ public String interface_name; - + /** Interface flags from SIOCGIFFLAGS */ public long flags; + - public MsgNetworkStateResp(int sender) { - super(sender, TYPE); - } - - public MsgNetworkStateResp() { - super(TYPE); - } - - public MsgNetworkStateResp(SBPMessage msg) throws SBPBinaryException { + public MsgNetworkStateResp (int sender) { super(sender, TYPE); } + public MsgNetworkStateResp () { super(TYPE); } + public MsgNetworkStateResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgNetworkStateResp, expected 187, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgNetworkStateResp, expected 187, actual " + msg.type); } @Override @@ -81,7 +82,7 @@ protected void parse(Parser parser) throws SBPBinaryException { rx_bytes = parser.getU32(); tx_bytes = parser.getU32(); interface_name = parser.getString(16); - flags = parser.getU32(); + flags = parser.getU32(); } @Override @@ -93,7 +94,7 @@ protected void build(Builder builder) { builder.putU32(rx_bytes); builder.putU32(tx_bytes); builder.putString(interface_name, 16); - builder.putU32(flags); + builder.putU32(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgReset.java b/java/src/com/swiftnav/sbp/piksi/MsgReset.java index d60fb5bc6..671451a32 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgReset.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgReset.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_RESET (0x00B6). +/** SBP class for message MSG_RESET (0x00B6). * - *

You can have MSG_RESET inherent its fields directly from an inherited SBP object, or construct - * it inline using a dict of its fields. + * You can have MSG_RESET inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message from the host resets the Piksi back into the bootloader. - */ + * This message from the host resets the Piksi back into the bootloader. */ + public class MsgReset extends SBPMessage { public static final int TYPE = 0x00B6; + /** Reset flags */ public long flags; + - public MsgReset(int sender) { - super(sender, TYPE); - } - - public MsgReset() { - super(TYPE); - } - - public MsgReset(SBPMessage msg) throws SBPBinaryException { + public MsgReset (int sender) { super(sender, TYPE); } + public MsgReset () { super(TYPE); } + public MsgReset (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgReset, expected 182, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgReset, expected 182, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - flags = parser.getU32(); + flags = parser.getU32(); } @Override protected void build(Builder builder) { - builder.putU32(flags); + builder.putU32(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgResetDep.java b/java/src/com/swiftnav/sbp/piksi/MsgResetDep.java index 70b5d030f..cba4bfdee 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgResetDep.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgResetDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,41 +9,42 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_RESET_DEP (0x00B2). +/** SBP class for message MSG_RESET_DEP (0x00B2). * - *

You can have MSG_RESET_DEP inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_RESET_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgResetDep extends SBPMessage { public static final int TYPE = 0x00B2; - public MsgResetDep(int sender) { - super(sender, TYPE); - } - - public MsgResetDep() { - super(TYPE); - } + - public MsgResetDep(SBPMessage msg) throws SBPBinaryException { + public MsgResetDep (int sender) { super(sender, TYPE); } + public MsgResetDep () { super(TYPE); } + public MsgResetDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgResetDep, expected 178, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgResetDep, expected 178, actual " + msg.type); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgResetFilters.java b/java/src/com/swiftnav/sbp/piksi/MsgResetFilters.java index 05791276a..dfe8540fa 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgResetFilters.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgResetFilters.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,57 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_RESET_FILTERS (0x0022). +/** SBP class for message MSG_RESET_FILTERS (0x0022). * - *

You can have MSG_RESET_FILTERS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_RESET_FILTERS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message resets either the DGNSS Kalman filters or Integer Ambiguity Resolution (IAR) - * process. - */ + * This message resets either the DGNSS Kalman filters or Integer Ambiguity + * Resolution (IAR) process. */ + public class MsgResetFilters extends SBPMessage { public static final int TYPE = 0x0022; + /** Filter flags */ public int filter; + - public MsgResetFilters(int sender) { - super(sender, TYPE); - } - - public MsgResetFilters() { - super(TYPE); - } - - public MsgResetFilters(SBPMessage msg) throws SBPBinaryException { + public MsgResetFilters (int sender) { super(sender, TYPE); } + public MsgResetFilters () { super(TYPE); } + public MsgResetFilters (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgResetFilters, expected 34, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgResetFilters, expected 34, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - filter = parser.getU8(); + filter = parser.getU8(); } @Override protected void build(Builder builder) { - builder.putU8(filter); + builder.putU8(filter); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgSetTime.java b/java/src/com/swiftnav/sbp/piksi/MsgSetTime.java index 8f4c67b8c..57bf6a275 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgSetTime.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgSetTime.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,41 +9,43 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SET_TIME (0x0068). +/** SBP class for message MSG_SET_TIME (0x0068). * - *

You can have MSG_SET_TIME inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_SET_TIME inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message sets up timing functionality using a coarse GPS time estimate sent by the host. - */ + * This message sets up timing functionality using a coarse GPS time estimate + * sent by the host. */ + public class MsgSetTime extends SBPMessage { public static final int TYPE = 0x0068; - public MsgSetTime(int sender) { - super(sender, TYPE); - } - - public MsgSetTime() { - super(TYPE); - } + - public MsgSetTime(SBPMessage msg) throws SBPBinaryException { + public MsgSetTime (int sender) { super(sender, TYPE); } + public MsgSetTime () { super(TYPE); } + public MsgSetTime (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSetTime, expected 104, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSetTime, expected 104, actual " + msg.type); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgSpecan.java b/java/src/com/swiftnav/sbp/piksi/MsgSpecan.java index 88b59b738..07bc3bd1a 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgSpecan.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgSpecan.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,63 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SPECAN (0x0051). +/** SBP class for message MSG_SPECAN (0x0051). * - *

You can have MSG_SPECAN inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_SPECAN inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Spectrum analyzer packet. - */ + * Spectrum analyzer packet. */ + public class MsgSpecan extends SBPMessage { public static final int TYPE = 0x0051; + /** Channel ID */ public int channel_tag; - + /** Receiver time of this observation */ public GPSTime t; - + /** Reference frequency of this packet */ public float freq_ref; - + /** Frequency step of points in this packet */ public float freq_step; - + /** Reference amplitude of this packet */ public float amplitude_ref; - + /** Amplitude unit value of points in this packet */ public float amplitude_unit; - + /** Amplitude values (in the above units) of points in this packet */ public int[] amplitude_value; + - public MsgSpecan(int sender) { - super(sender, TYPE); - } - - public MsgSpecan() { - super(TYPE); - } - - public MsgSpecan(SBPMessage msg) throws SBPBinaryException { + public MsgSpecan (int sender) { super(sender, TYPE); } + public MsgSpecan () { super(TYPE); } + public MsgSpecan (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSpecan, expected 81, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSpecan, expected 81, actual " + msg.type); } @Override @@ -76,7 +77,7 @@ protected void parse(Parser parser) throws SBPBinaryException { freq_step = parser.getFloat(); amplitude_ref = parser.getFloat(); amplitude_unit = parser.getFloat(); - amplitude_value = parser.getArrayofU8(); + amplitude_value = parser.getArrayofU8(); } @Override @@ -87,7 +88,7 @@ protected void build(Builder builder) { builder.putFloat(freq_step); builder.putFloat(amplitude_ref); builder.putFloat(amplitude_unit); - builder.putArrayofU8(amplitude_value); + builder.putArrayofU8(amplitude_value); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgSpecanDep.java b/java/src/com/swiftnav/sbp/piksi/MsgSpecanDep.java index fc30de19c..a1306ff06 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgSpecanDep.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgSpecanDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,63 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SPECAN_DEP (0x0050). +/** SBP class for message MSG_SPECAN_DEP (0x0050). * - *

You can have MSG_SPECAN_DEP inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_SPECAN_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSpecanDep extends SBPMessage { public static final int TYPE = 0x0050; + /** Channel ID */ public int channel_tag; - + /** Receiver time of this observation */ public GPSTimeDep t; - + /** Reference frequency of this packet */ public float freq_ref; - + /** Frequency step of points in this packet */ public float freq_step; - + /** Reference amplitude of this packet */ public float amplitude_ref; - + /** Amplitude unit value of points in this packet */ public float amplitude_unit; - + /** Amplitude values (in the above units) of points in this packet */ public int[] amplitude_value; + - public MsgSpecanDep(int sender) { - super(sender, TYPE); - } - - public MsgSpecanDep() { - super(TYPE); - } - - public MsgSpecanDep(SBPMessage msg) throws SBPBinaryException { + public MsgSpecanDep (int sender) { super(sender, TYPE); } + public MsgSpecanDep () { super(TYPE); } + public MsgSpecanDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSpecanDep, expected 80, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSpecanDep, expected 80, actual " + msg.type); } @Override @@ -76,7 +77,7 @@ protected void parse(Parser parser) throws SBPBinaryException { freq_step = parser.getFloat(); amplitude_ref = parser.getFloat(); amplitude_unit = parser.getFloat(); - amplitude_value = parser.getArrayofU8(); + amplitude_value = parser.getArrayofU8(); } @Override @@ -87,7 +88,7 @@ protected void build(Builder builder) { builder.putFloat(freq_step); builder.putFloat(amplitude_ref); builder.putFloat(amplitude_unit); - builder.putArrayofU8(amplitude_value); + builder.putArrayofU8(amplitude_value); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgThreadState.java b/java/src/com/swiftnav/sbp/piksi/MsgThreadState.java index 61c988f34..9eb66531d 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgThreadState.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgThreadState.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,54 +9,54 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_THREAD_STATE (0x0017). + +/** SBP class for message MSG_THREAD_STATE (0x0017). * - *

You can have MSG_THREAD_STATE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_THREAD_STATE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The thread usage message from the device reports real-time operating system (RTOS) thread - * usage statistics for the named thread. The reported percentage values must be normalized. - */ + * The thread usage message from the device reports real-time operating system + * (RTOS) thread usage statistics for the named thread. The reported + * percentage values must be normalized. */ + public class MsgThreadState extends SBPMessage { public static final int TYPE = 0x0017; + /** Thread name (NULL terminated) */ public String name; - - /** - * Percentage cpu use for this thread. Values range from 0 - 1000 and needs to be renormalized - * to 100 - */ + + /** Percentage cpu use for this thread. Values range from 0 - 1000 and + * needs to be renormalized to 100 */ public int cpu; - + /** Free stack space for this thread */ public long stack_free; + - public MsgThreadState(int sender) { - super(sender, TYPE); - } - - public MsgThreadState() { - super(TYPE); - } - - public MsgThreadState(SBPMessage msg) throws SBPBinaryException { + public MsgThreadState (int sender) { super(sender, TYPE); } + public MsgThreadState () { super(TYPE); } + public MsgThreadState (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgThreadState, expected 23, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgThreadState, expected 23, actual " + msg.type); } @Override @@ -63,14 +64,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ name = parser.getString(20); cpu = parser.getU16(); - stack_free = parser.getU32(); + stack_free = parser.getU32(); } @Override protected void build(Builder builder) { builder.putString(name, 20); builder.putU16(cpu); - builder.putU32(stack_free); + builder.putU32(stack_free); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgUartState.java b/java/src/com/swiftnav/sbp/piksi/MsgUartState.java index fa7d294ea..c4ecb9608 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgUartState.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgUartState.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,64 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_UART_STATE (0x001D). + +/** SBP class for message MSG_UART_STATE (0x001D). * - *

You can have MSG_UART_STATE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_UART_STATE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The UART message reports data latency and throughput of the UART channels providing SBP I/O. - * On the default Piksi configuration, UARTs A and B are used for telemetry radios, but can also be - * host access ports for embedded hosts, or other interfaces in future. The reported percentage - * values must be normalized. Observations latency and period can be used to assess the health of - * the differential corrections link. Latency provides the timeliness of received base observations - * while the period indicates their likelihood of transmission. - */ + * The UART message reports data latency and throughput of the UART channels + * providing SBP I/O. On the default Piksi configuration, UARTs A and B are + * used for telemetry radios, but can also be host access ports for embedded + * hosts, or other interfaces in future. The reported percentage values must + * be normalized. Observations latency and period can be used to assess the + * health of the differential corrections link. Latency provides the + * timeliness of received base observations while the period indicates their + * likelihood of transmission. */ + public class MsgUartState extends SBPMessage { public static final int TYPE = 0x001D; + /** State of UART A */ public UARTChannel uart_a; - + /** State of UART B */ public UARTChannel uart_b; - + /** State of UART FTDI (USB logger) */ public UARTChannel uart_ftdi; - + /** UART communication latency */ public Latency latency; - + /** Observation receipt period */ public Period obs_period; + - public MsgUartState(int sender) { - super(sender, TYPE); - } - - public MsgUartState() { - super(TYPE); - } - - public MsgUartState(SBPMessage msg) throws SBPBinaryException { + public MsgUartState (int sender) { super(sender, TYPE); } + public MsgUartState () { super(TYPE); } + public MsgUartState (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgUartState, expected 29, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgUartState, expected 29, actual " + msg.type); } @Override @@ -72,7 +76,7 @@ protected void parse(Parser parser) throws SBPBinaryException { uart_b = new UARTChannel().parse(parser); uart_ftdi = new UARTChannel().parse(parser); latency = new Latency().parse(parser); - obs_period = new Period().parse(parser); + obs_period = new Period().parse(parser); } @Override @@ -81,7 +85,7 @@ protected void build(Builder builder) { uart_b.build(builder); uart_ftdi.build(builder); latency.build(builder); - obs_period.build(builder); + obs_period.build(builder); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/MsgUartStateDepa.java b/java/src/com/swiftnav/sbp/piksi/MsgUartStateDepa.java index 2eafa5820..87230c6ff 100644 --- a/java/src/com/swiftnav/sbp/piksi/MsgUartStateDepa.java +++ b/java/src/com/swiftnav/sbp/piksi/MsgUartStateDepa.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,53 +9,54 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_UART_STATE_DEPA (0x0018). + +/** SBP class for message MSG_UART_STATE_DEPA (0x0018). * - *

You can have MSG_UART_STATE_DEPA inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_UART_STATE_DEPA inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgUartStateDepa extends SBPMessage { public static final int TYPE = 0x0018; + /** State of UART A */ public UARTChannel uart_a; - + /** State of UART B */ public UARTChannel uart_b; - + /** State of UART FTDI (USB logger) */ public UARTChannel uart_ftdi; - + /** UART communication latency */ public Latency latency; + - public MsgUartStateDepa(int sender) { - super(sender, TYPE); - } - - public MsgUartStateDepa() { - super(TYPE); - } - - public MsgUartStateDepa(SBPMessage msg) throws SBPBinaryException { + public MsgUartStateDepa (int sender) { super(sender, TYPE); } + public MsgUartStateDepa () { super(TYPE); } + public MsgUartStateDepa (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgUartStateDepa, expected 24, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgUartStateDepa, expected 24, actual " + msg.type); } @Override @@ -63,7 +65,7 @@ protected void parse(Parser parser) throws SBPBinaryException { uart_a = new UARTChannel().parse(parser); uart_b = new UARTChannel().parse(parser); uart_ftdi = new UARTChannel().parse(parser); - latency = new Latency().parse(parser); + latency = new Latency().parse(parser); } @Override @@ -71,7 +73,7 @@ protected void build(Builder builder) { uart_a.build(builder); uart_b.build(builder); uart_ftdi.build(builder); - latency.build(builder); + latency.build(builder); } @Override diff --git a/java/src/com/swiftnav/sbp/piksi/NetworkUsage.java b/java/src/com/swiftnav/sbp/piksi/NetworkUsage.java index 8b1c13dfb..7e804659d 100644 --- a/java/src/com/swiftnav/sbp/piksi/NetworkUsage.java +++ b/java/src/com/swiftnav/sbp/piksi/NetworkUsage.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,37 +9,41 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import java.math.BigInteger; + import org.json.JSONObject; +import org.json.JSONArray; public class NetworkUsage extends SBPStruct { - + /** Duration over which the measurement was collected */ public BigInteger duration; - + /** Number of bytes handled in total within period */ public BigInteger total_bytes; - + /** Number of bytes transmitted within period */ public long rx_bytes; - + /** Number of bytes received within period */ public long tx_bytes; - + /** Interface Name */ public String interface_name; + - public NetworkUsage() {} + public NetworkUsage () {} @Override public NetworkUsage parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/piksi/Period.java b/java/src/com/swiftnav/sbp/piksi/Period.java index 5667c5c3b..44540a921 100644 --- a/java/src/com/swiftnav/sbp/piksi/Period.java +++ b/java/src/com/swiftnav/sbp/piksi/Period.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,33 +9,38 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class Period extends SBPStruct { - + /** Average period */ public int avg; - + /** Minimum period */ public int pmin; - + /** Maximum period */ public int pmax; - + /** Smoothed estimate of the current period */ public int current; + - public Period() {} + public Period () {} @Override public Period parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/piksi/UARTChannel.java b/java/src/com/swiftnav/sbp/piksi/UARTChannel.java index fdae284ff..a7ce9ad81 100644 --- a/java/src/com/swiftnav/sbp/piksi/UARTChannel.java +++ b/java/src/com/swiftnav/sbp/piksi/UARTChannel.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,39 +9,44 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.piksi; // This file was auto-generated from yaml/swiftnav/sbp/piksi.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class UARTChannel extends SBPStruct { - + /** UART transmit throughput */ public float tx_throughput; - + /** UART receive throughput */ public float rx_throughput; - + /** UART CRC error count */ public int crc_error_count; - + /** UART IO error count */ public int io_error_count; - + /** UART transmit buffer percentage utilization (ranges from 0 to 255) */ public int tx_buffer_level; - + /** UART receive buffer percentage utilization (ranges from 0 to 255) */ public int rx_buffer_level; + - public UARTChannel() {} + public UARTChannel () {} @Override public UARTChannel parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/profiling/MsgMeasurementPoint.java b/java/src/com/swiftnav/sbp/profiling/MsgMeasurementPoint.java index c454817c5..1362d997a 100644 --- a/java/src/com/swiftnav/sbp/profiling/MsgMeasurementPoint.java +++ b/java/src/com/swiftnav/sbp/profiling/MsgMeasurementPoint.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,69 +9,70 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.profiling; // This file was auto-generated from yaml/swiftnav/sbp/profiling.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import java.math.BigInteger; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_MEASUREMENT_POINT (0xCF00). + +/** SBP class for message MSG_MEASUREMENT_POINT (0xCF00). * - *

You can have MSG_MEASUREMENT_POINT inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_MEASUREMENT_POINT inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Tracks execution time of certain code paths in specially built products. This message should - * only be expected and processed on the direction of Swift's engineering teams. - */ + * Tracks execution time of certain code paths in specially built products. + * This message should only be expected and processed on the direction of + * Swift's engineering teams. */ + public class MsgMeasurementPoint extends SBPMessage { public static final int TYPE = 0xCF00; + /** Total time spent in measurement point (microseconds) */ public long total_time; - + /** Number of times measurement point has executed */ public int num_executions; - + /** Minimum execution time (microseconds) */ public long min; - + /** Maximum execution time (microseconds) */ public long max; - + /** Return address */ public BigInteger return_addr; - + /** Unique ID */ public BigInteger id; - + /** CPU slice time (milliseconds) */ public BigInteger slice_time; - + /** Line number */ public int line; - + /** Function name */ public String func; + - public MsgMeasurementPoint(int sender) { - super(sender, TYPE); - } - - public MsgMeasurementPoint() { - super(TYPE); - } - - public MsgMeasurementPoint(SBPMessage msg) throws SBPBinaryException { + public MsgMeasurementPoint (int sender) { super(sender, TYPE); } + public MsgMeasurementPoint () { super(TYPE); } + public MsgMeasurementPoint (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgMeasurementPoint, expected 52992, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgMeasurementPoint, expected 52992, actual " + msg.type); } @Override @@ -84,7 +86,7 @@ protected void parse(Parser parser) throws SBPBinaryException { id = parser.getU64(); slice_time = parser.getU64(); line = parser.getU16(); - func = parser.getString(); + func = parser.getString(); } @Override @@ -97,7 +99,7 @@ protected void build(Builder builder) { builder.putU64(id); builder.putU64(slice_time); builder.putU16(line); - builder.putString(func); + builder.putString(func); } @Override diff --git a/java/src/com/swiftnav/sbp/profiling/MsgProfilingResourceCounter.java b/java/src/com/swiftnav/sbp/profiling/MsgProfilingResourceCounter.java index 0f483719e..167bf7343 100644 --- a/java/src/com/swiftnav/sbp/profiling/MsgProfilingResourceCounter.java +++ b/java/src/com/swiftnav/sbp/profiling/MsgProfilingResourceCounter.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,52 +9,51 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.profiling; // This file was auto-generated from yaml/swiftnav/sbp/profiling.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_PROFILING_RESOURCE_COUNTER (0xCF03). + +/** SBP class for message MSG_PROFILING_RESOURCE_COUNTER (0xCF03). * - *

You can have MSG_PROFILING_RESOURCE_COUNTER inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_PROFILING_RESOURCE_COUNTER inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Information about resource buckets. Refer to product documentation to understand the meaning - * and values in this message. - */ + * Information about resource buckets. Refer to product documentation to + * understand the meaning and values in this message. */ + public class MsgProfilingResourceCounter extends SBPMessage { public static final int TYPE = 0xCF03; + /** Message number in complete sequence */ public int seq_no; - + /** Length of message sequence */ public int seq_len; - + /** List of resource buckets */ public ResourceBucket[] buckets; + - public MsgProfilingResourceCounter(int sender) { - super(sender, TYPE); - } - - public MsgProfilingResourceCounter() { - super(TYPE); - } - - public MsgProfilingResourceCounter(SBPMessage msg) throws SBPBinaryException { + public MsgProfilingResourceCounter (int sender) { super(sender, TYPE); } + public MsgProfilingResourceCounter () { super(TYPE); } + public MsgProfilingResourceCounter (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgProfilingResourceCounter, expected 52995, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgProfilingResourceCounter, expected 52995, actual " + msg.type); } @Override @@ -61,14 +61,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ seq_no = parser.getU8(); seq_len = parser.getU8(); - buckets = parser.getArray(ResourceBucket.class); + buckets = parser.getArray(ResourceBucket.class); } @Override protected void build(Builder builder) { builder.putU8(seq_no); builder.putU8(seq_len); - builder.putArray(buckets); + builder.putArray(buckets); } @Override diff --git a/java/src/com/swiftnav/sbp/profiling/MsgProfilingSystemInfo.java b/java/src/com/swiftnav/sbp/profiling/MsgProfilingSystemInfo.java index c59470c12..919601856 100644 --- a/java/src/com/swiftnav/sbp/profiling/MsgProfilingSystemInfo.java +++ b/java/src/com/swiftnav/sbp/profiling/MsgProfilingSystemInfo.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.profiling; // This file was auto-generated from yaml/swiftnav/sbp/profiling.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import java.math.BigInteger; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_PROFILING_SYSTEM_INFO (0xCF01). + +/** SBP class for message MSG_PROFILING_SYSTEM_INFO (0xCF01). * - *

You can have MSG_PROFILING_SYSTEM_INFO inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_PROFILING_SYSTEM_INFO inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Contains basic information about system resource usage. System is defined in terms of the - * source of this message and may vary from sender to sender. Refer to product documentation to - * understand the exact scope and meaning of this message. - */ + * Contains basic information about system resource usage. System is defined + * in terms of the source of this message and may vary from sender to sender. + * Refer to product documentation to understand the exact scope and meaning of + * this message. */ + public class MsgProfilingSystemInfo extends SBPMessage { public static final int TYPE = 0xCF01; + /** Total cpu time in microseconds consumed by this system */ public BigInteger total_cpu_time; - + /** Age of the producing system in microseconds */ public BigInteger age; - + /** Number of threads being tracked by this system */ public int n_threads; - + /** Number of bytes allocated on the heap */ public long heap_usage; + - public MsgProfilingSystemInfo(int sender) { - super(sender, TYPE); - } - - public MsgProfilingSystemInfo() { - super(TYPE); - } - - public MsgProfilingSystemInfo(SBPMessage msg) throws SBPBinaryException { + public MsgProfilingSystemInfo (int sender) { super(sender, TYPE); } + public MsgProfilingSystemInfo () { super(TYPE); } + public MsgProfilingSystemInfo (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgProfilingSystemInfo, expected 52993, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgProfilingSystemInfo, expected 52993, actual " + msg.type); } @Override @@ -65,7 +67,7 @@ protected void parse(Parser parser) throws SBPBinaryException { total_cpu_time = parser.getU64(); age = parser.getU64(); n_threads = parser.getU8(); - heap_usage = parser.getU32(); + heap_usage = parser.getU32(); } @Override @@ -73,7 +75,7 @@ protected void build(Builder builder) { builder.putU64(total_cpu_time); builder.putU64(age); builder.putU8(n_threads); - builder.putU32(heap_usage); + builder.putU32(heap_usage); } @Override diff --git a/java/src/com/swiftnav/sbp/profiling/MsgProfilingThreadInfo.java b/java/src/com/swiftnav/sbp/profiling/MsgProfilingThreadInfo.java index e85f000f7..dbcd3e08d 100644 --- a/java/src/com/swiftnav/sbp/profiling/MsgProfilingThreadInfo.java +++ b/java/src/com/swiftnav/sbp/profiling/MsgProfilingThreadInfo.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,61 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.profiling; // This file was auto-generated from yaml/swiftnav/sbp/profiling.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import java.math.BigInteger; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_PROFILING_THREAD_INFO (0xCF02). +/** SBP class for message MSG_PROFILING_THREAD_INFO (0xCF02). * - *

You can have MSG_PROFILING_THREAD_INFO inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_PROFILING_THREAD_INFO inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Contains profiling information related to a single thread being tracked by the producing - * system. Refer to product documentation to understand the exact scope and meaning of this message. - */ + * Contains profiling information related to a single thread being tracked by + * the producing system. Refer to product documentation to understand the + * exact scope and meaning of this message. */ + public class MsgProfilingThreadInfo extends SBPMessage { public static final int TYPE = 0xCF02; + /** Total cpu time in microseconds consumed by this thread */ public BigInteger total_cpu_time; - + /** Age of the thread in microseconds */ public BigInteger age; - + /** Thread state */ public int state; - + /** Stack size in bytes */ public long stack_size; - + /** Stack high water usage in bytes */ public long stack_usage; - + /** Thread name */ public String name; + - public MsgProfilingThreadInfo(int sender) { - super(sender, TYPE); - } - - public MsgProfilingThreadInfo() { - super(TYPE); - } - - public MsgProfilingThreadInfo(SBPMessage msg) throws SBPBinaryException { + public MsgProfilingThreadInfo (int sender) { super(sender, TYPE); } + public MsgProfilingThreadInfo () { super(TYPE); } + public MsgProfilingThreadInfo (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgProfilingThreadInfo, expected 52994, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgProfilingThreadInfo, expected 52994, actual " + msg.type); } @Override @@ -72,7 +74,7 @@ protected void parse(Parser parser) throws SBPBinaryException { state = parser.getU8(); stack_size = parser.getU32(); stack_usage = parser.getU32(); - name = parser.getString(); + name = parser.getString(); } @Override @@ -82,7 +84,7 @@ protected void build(Builder builder) { builder.putU8(state); builder.putU32(stack_size); builder.putU32(stack_usage); - builder.putString(name); + builder.putString(name); } @Override diff --git a/java/src/com/swiftnav/sbp/profiling/ResourceBucket.java b/java/src/com/swiftnav/sbp/profiling/ResourceBucket.java index 4795ca39c..86419a022 100644 --- a/java/src/com/swiftnav/sbp/profiling/ResourceBucket.java +++ b/java/src/com/swiftnav/sbp/profiling/ResourceBucket.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,47 +9,52 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.profiling; // This file was auto-generated from yaml/swiftnav/sbp/profiling.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class ResourceBucket extends SBPStruct { - + /** Bucket name */ public String name; - + /** Number of threads */ public int thread; - + /** Number of mutexes */ public int mutex; - + /** Number of condition variables */ public int cv; - + /** Number of IO handles */ public int io; - + /** Number of bytes allocated on the heap */ public long heap_bytes_alloc; - + /** Number of bytes freed on the heap */ public long heap_bytes_free; - + /** Number of bytes written to IO handles */ public long io_write; - + /** Number of bytes read from IO handles */ public long io_read; + - public ResourceBucket() {} + public ResourceBucket () {} @Override public ResourceBucket parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/sbas/MsgSbasRaw.java b/java/src/com/swiftnav/sbp/sbas/MsgSbasRaw.java index 2e0dfd364..c07a2b53e 100644 --- a/java/src/com/swiftnav/sbp/sbas/MsgSbasRaw.java +++ b/java/src/com/swiftnav/sbp/sbas/MsgSbasRaw.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,55 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.sbas; // This file was auto-generated from yaml/swiftnav/sbp/sbas.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_SBAS_RAW (0x7777). + +/** SBP class for message MSG_SBAS_RAW (0x7777). * - *

You can have MSG_SBAS_RAW inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_SBAS_RAW inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message is sent once per second per SBAS satellite. ME checks the parity of the data - * block and sends only blocks that pass the check. - */ + * This message is sent once per second per SBAS satellite. ME checks the + * parity of the data block and sends only blocks that pass the check. */ + public class MsgSbasRaw extends SBPMessage { public static final int TYPE = 0x7777; + /** GNSS signal identifier. */ public GnssSignal sid; - + /** GPS time-of-week at the start of the data block. */ public long tow; - + /** SBAS message type (0-63) */ public int message_type; - + /** Raw SBAS data field of 212 bits (last byte padded with zeros). */ public int[] data; + - public MsgSbasRaw(int sender) { - super(sender, TYPE); - } - - public MsgSbasRaw() { - super(TYPE); - } - - public MsgSbasRaw(SBPMessage msg) throws SBPBinaryException { + public MsgSbasRaw (int sender) { super(sender, TYPE); } + public MsgSbasRaw () { super(TYPE); } + public MsgSbasRaw (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSbasRaw, expected 30583, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSbasRaw, expected 30583, actual " + msg.type); } @Override @@ -65,7 +66,7 @@ protected void parse(Parser parser) throws SBPBinaryException { sid = new GnssSignal().parse(parser); tow = parser.getU32(); message_type = parser.getU8(); - data = parser.getArrayofU8(27); + data = parser.getArrayofU8(27); } @Override @@ -73,7 +74,7 @@ protected void build(Builder builder) { sid.build(builder); builder.putU32(tow); builder.putU8(message_type); - builder.putArrayofU8(data, 27); + builder.putArrayofU8(data, 27); } @Override diff --git a/java/src/com/swiftnav/sbp/settings/MsgSettingsReadByIndexDone.java b/java/src/com/swiftnav/sbp/settings/MsgSettingsReadByIndexDone.java index 0aa756b9d..f7f8c3ecb 100644 --- a/java/src/com/swiftnav/sbp/settings/MsgSettingsReadByIndexDone.java +++ b/java/src/com/swiftnav/sbp/settings/MsgSettingsReadByIndexDone.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,41 +9,41 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.settings; // This file was auto-generated from yaml/swiftnav/sbp/settings.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SETTINGS_READ_BY_INDEX_DONE (0x00A6). +/** SBP class for message MSG_SETTINGS_READ_BY_INDEX_DONE (0x00A6). * - *

You can have MSG_SETTINGS_READ_BY_INDEX_DONE inherent its fields directly from an inherited - * SBP object, or construct it inline using a dict of its fields. + * You can have MSG_SETTINGS_READ_BY_INDEX_DONE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The settings message for indicating end of the settings values. - */ + * The settings message for indicating end of the settings values. */ + public class MsgSettingsReadByIndexDone extends SBPMessage { public static final int TYPE = 0x00A6; - public MsgSettingsReadByIndexDone(int sender) { - super(sender, TYPE); - } - - public MsgSettingsReadByIndexDone() { - super(TYPE); - } + - public MsgSettingsReadByIndexDone(SBPMessage msg) throws SBPBinaryException { + public MsgSettingsReadByIndexDone (int sender) { super(sender, TYPE); } + public MsgSettingsReadByIndexDone () { super(TYPE); } + public MsgSettingsReadByIndexDone (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSettingsReadByIndexDone, expected 166, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSettingsReadByIndexDone, expected 166, actual " + msg.type); } @Override diff --git a/java/src/com/swiftnav/sbp/settings/MsgSettingsReadByIndexReq.java b/java/src/com/swiftnav/sbp/settings/MsgSettingsReadByIndexReq.java index 3f28dfa4a..9524171fa 100644 --- a/java/src/com/swiftnav/sbp/settings/MsgSettingsReadByIndexReq.java +++ b/java/src/com/swiftnav/sbp/settings/MsgSettingsReadByIndexReq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,57 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.settings; // This file was auto-generated from yaml/swiftnav/sbp/settings.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SETTINGS_READ_BY_INDEX_REQ (0x00A2). +/** SBP class for message MSG_SETTINGS_READ_BY_INDEX_REQ (0x00A2). * - *

You can have MSG_SETTINGS_READ_BY_INDEX_REQ inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SETTINGS_READ_BY_INDEX_REQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The settings message for iterating through the settings values. A device will respond to this - * message with a "MSG_SETTINGS_READ_BY_INDEX_RESP". - */ + * The settings message for iterating through the settings values. A device + * will respond to this message with a "MSG_SETTINGS_READ_BY_INDEX_RESP". */ + public class MsgSettingsReadByIndexReq extends SBPMessage { public static final int TYPE = 0x00A2; - /** An index into the device settings, with values ranging from 0 to length(settings). */ + + /** An index into the device settings, with values ranging from 0 to + * length(settings). */ public int index; + - public MsgSettingsReadByIndexReq(int sender) { - super(sender, TYPE); - } - - public MsgSettingsReadByIndexReq() { - super(TYPE); - } - - public MsgSettingsReadByIndexReq(SBPMessage msg) throws SBPBinaryException { + public MsgSettingsReadByIndexReq (int sender) { super(sender, TYPE); } + public MsgSettingsReadByIndexReq () { super(TYPE); } + public MsgSettingsReadByIndexReq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSettingsReadByIndexReq, expected 162, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSettingsReadByIndexReq, expected 162, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - index = parser.getU16(); + index = parser.getU16(); } @Override protected void build(Builder builder) { - builder.putU16(index); + builder.putU16(index); } @Override diff --git a/java/src/com/swiftnav/sbp/settings/MsgSettingsReadByIndexResp.java b/java/src/com/swiftnav/sbp/settings/MsgSettingsReadByIndexResp.java index 45106144d..e1bd50224 100644 --- a/java/src/com/swiftnav/sbp/settings/MsgSettingsReadByIndexResp.java +++ b/java/src/com/swiftnav/sbp/settings/MsgSettingsReadByIndexResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,70 +9,71 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.settings; // This file was auto-generated from yaml/swiftnav/sbp/settings.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SETTINGS_READ_BY_INDEX_RESP (0x00A7). +/** SBP class for message MSG_SETTINGS_READ_BY_INDEX_RESP (0x00A7). * - *

You can have MSG_SETTINGS_READ_BY_INDEX_RESP inherent its fields directly from an inherited - * SBP object, or construct it inline using a dict of its fields. + * You can have MSG_SETTINGS_READ_BY_INDEX_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The settings message that reports the value of a setting at an index. + * The settings message that reports the value of a setting at an index. * - *

In the string field, it reports NULL-terminated and delimited string with contents - * "SECTION_SETTING\0SETTING\0VALUE\0FORMAT_TYPE\0". where the '\0' escape sequence denotes the NULL - * character and where quotation marks are omitted. The FORMAT_TYPE field is optional and denotes - * possible string values of the setting as a hint to the user. If included, the format type portion - * of the string has the format "enum:value1,value2,value3". An example string that could be sent - * from the device is "simulator\0enabled\0True\0enum:True,False\0". - */ + * In the string field, it reports NULL-terminated and delimited string with + * contents "SECTION_SETTING\0SETTING\0VALUE\0FORMAT_TYPE\0". where the '\0' + * escape sequence denotes the NULL character and where quotation marks are + * omitted. The FORMAT_TYPE field is optional and denotes possible string + * values of the setting as a hint to the user. If included, the format type + * portion of the string has the format "enum:value1,value2,value3". An + * example string that could be sent from the device is + * "simulator\0enabled\0True\0enum:True,False\0". */ + public class MsgSettingsReadByIndexResp extends SBPMessage { public static final int TYPE = 0x00A7; - /** An index into the device settings, with values ranging from 0 to length(settings) */ + + /** An index into the device settings, with values ranging from 0 to + * length(settings) */ public int index; - - /** - * A NULL-terminated and delimited string with contents - * "SECTION_SETTING\0SETTING\0VALUE\0FORMAT_TYPE\0" - */ + + /** A NULL-terminated and delimited string with contents + * "SECTION_SETTING\0SETTING\0VALUE\0FORMAT_TYPE\0" */ public String setting; + - public MsgSettingsReadByIndexResp(int sender) { - super(sender, TYPE); - } - - public MsgSettingsReadByIndexResp() { - super(TYPE); - } - - public MsgSettingsReadByIndexResp(SBPMessage msg) throws SBPBinaryException { + public MsgSettingsReadByIndexResp (int sender) { super(sender, TYPE); } + public MsgSettingsReadByIndexResp () { super(TYPE); } + public MsgSettingsReadByIndexResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSettingsReadByIndexResp, expected 167, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSettingsReadByIndexResp, expected 167, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ index = parser.getU16(); - setting = parser.getString(); + setting = parser.getString(); } @Override protected void build(Builder builder) { builder.putU16(index); - builder.putString(setting); + builder.putString(setting); } @Override diff --git a/java/src/com/swiftnav/sbp/settings/MsgSettingsReadReq.java b/java/src/com/swiftnav/sbp/settings/MsgSettingsReadReq.java index ec091171b..2bb0e6b3e 100644 --- a/java/src/com/swiftnav/sbp/settings/MsgSettingsReadReq.java +++ b/java/src/com/swiftnav/sbp/settings/MsgSettingsReadReq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,59 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.settings; // This file was auto-generated from yaml/swiftnav/sbp/settings.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SETTINGS_READ_REQ (0x00A4). +/** SBP class for message MSG_SETTINGS_READ_REQ (0x00A4). * - *

You can have MSG_SETTINGS_READ_REQ inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_SETTINGS_READ_REQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The setting message that reads the device configuration. The string field is a NULL-terminated - * and NULL-delimited string with contents "SECTION_SETTING\0SETTING\0" where the '\0' escape - * sequence denotes the NULL character and where quotation marks are omitted. An example string that - * could be sent to a device is "solution\0soln_freq\0". A device will only respond to this message - * when it is received from sender ID 0x42. A device should respond with a MSG_SETTINGS_READ_RESP - * message (msg_id 0x00A5). - */ + * The setting message that reads the device configuration. The string field + * is a NULL-terminated and NULL-delimited string with contents + * "SECTION_SETTING\0SETTING\0" where the '\0' escape sequence denotes the + * NULL character and where quotation marks are omitted. An example string + * that could be sent to a device is "solution\0soln_freq\0". A device will + * only respond to this message when it is received from sender ID 0x42. A + * device should respond with a MSG_SETTINGS_READ_RESP message (msg_id + * 0x00A5). */ + public class MsgSettingsReadReq extends SBPMessage { public static final int TYPE = 0x00A4; - /** A NULL-terminated and NULL-delimited string with contents "SECTION_SETTING\0SETTING\0" */ + + /** A NULL-terminated and NULL-delimited string with contents + * "SECTION_SETTING\0SETTING\0" */ public String setting; + - public MsgSettingsReadReq(int sender) { - super(sender, TYPE); - } - - public MsgSettingsReadReq() { - super(TYPE); - } - - public MsgSettingsReadReq(SBPMessage msg) throws SBPBinaryException { + public MsgSettingsReadReq (int sender) { super(sender, TYPE); } + public MsgSettingsReadReq () { super(TYPE); } + public MsgSettingsReadReq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSettingsReadReq, expected 164, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSettingsReadReq, expected 164, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - setting = parser.getString(); + setting = parser.getString(); } @Override protected void build(Builder builder) { - builder.putString(setting); + builder.putString(setting); } @Override diff --git a/java/src/com/swiftnav/sbp/settings/MsgSettingsReadResp.java b/java/src/com/swiftnav/sbp/settings/MsgSettingsReadResp.java index 0c4248115..56a7bf69a 100644 --- a/java/src/com/swiftnav/sbp/settings/MsgSettingsReadResp.java +++ b/java/src/com/swiftnav/sbp/settings/MsgSettingsReadResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,61 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.settings; // This file was auto-generated from yaml/swiftnav/sbp/settings.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SETTINGS_READ_RESP (0x00A5). +/** SBP class for message MSG_SETTINGS_READ_RESP (0x00A5). * - *

You can have MSG_SETTINGS_READ_RESP inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_SETTINGS_READ_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The setting message with which the device responds after a MSG_SETTING_READ_REQ is sent to - * device. The string field is a NULL- terminated and NULL-delimited string with contents - * "SECTION_SETTING\0SETTING\0VALUE\0" where the '\0' escape sequence denotes the NULL character and - * where quotation marks are omitted. An example string that could be sent from device is - * "solution\0soln_freq\010\0". - */ + * The setting message with which the device responds after a + * MSG_SETTING_READ_REQ is sent to device. The string field is a NULL- + * terminated and NULL-delimited string with contents + * "SECTION_SETTING\0SETTING\0VALUE\0" where the '\0' escape sequence denotes + * the NULL character and where quotation marks are omitted. An example string + * that could be sent from device is "solution\0soln_freq\010\0". */ + public class MsgSettingsReadResp extends SBPMessage { public static final int TYPE = 0x00A5; - /** - * A NULL-terminated and NULL-delimited string with contents "SECTION_SETTING\0SETTING\0VALUE\0" - */ + + /** A NULL-terminated and NULL-delimited string with contents + * "SECTION_SETTING\0SETTING\0VALUE\0" */ public String setting; + - public MsgSettingsReadResp(int sender) { - super(sender, TYPE); - } - - public MsgSettingsReadResp() { - super(TYPE); - } - - public MsgSettingsReadResp(SBPMessage msg) throws SBPBinaryException { + public MsgSettingsReadResp (int sender) { super(sender, TYPE); } + public MsgSettingsReadResp () { super(TYPE); } + public MsgSettingsReadResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSettingsReadResp, expected 165, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSettingsReadResp, expected 165, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - setting = parser.getString(); + setting = parser.getString(); } @Override protected void build(Builder builder) { - builder.putString(setting); + builder.putString(setting); } @Override diff --git a/java/src/com/swiftnav/sbp/settings/MsgSettingsRegister.java b/java/src/com/swiftnav/sbp/settings/MsgSettingsRegister.java index 198ce892d..0f6d5c862 100644 --- a/java/src/com/swiftnav/sbp/settings/MsgSettingsRegister.java +++ b/java/src/com/swiftnav/sbp/settings/MsgSettingsRegister.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.settings; // This file was auto-generated from yaml/swiftnav/sbp/settings.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SETTINGS_REGISTER (0x00AE). +/** SBP class for message MSG_SETTINGS_REGISTER (0x00AE). * - *

You can have MSG_SETTINGS_REGISTER inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_SETTINGS_REGISTER inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message registers the presence and default value of a setting with a settings daemon. The - * host should reply with MSG_SETTINGS_WRITE for this setting to set the initial value. - */ + * This message registers the presence and default value of a setting with a + * settings daemon. The host should reply with MSG_SETTINGS_WRITE for this + * setting to set the initial value. */ + public class MsgSettingsRegister extends SBPMessage { public static final int TYPE = 0x00AE; - /** A NULL-terminated and delimited string with contents "SECTION_SETTING\0SETTING\0VALUE". */ + + /** A NULL-terminated and delimited string with contents + * "SECTION_SETTING\0SETTING\0VALUE". */ public String setting; + - public MsgSettingsRegister(int sender) { - super(sender, TYPE); - } - - public MsgSettingsRegister() { - super(TYPE); - } - - public MsgSettingsRegister(SBPMessage msg) throws SBPBinaryException { + public MsgSettingsRegister (int sender) { super(sender, TYPE); } + public MsgSettingsRegister () { super(TYPE); } + public MsgSettingsRegister (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSettingsRegister, expected 174, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSettingsRegister, expected 174, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - setting = parser.getString(); + setting = parser.getString(); } @Override protected void build(Builder builder) { - builder.putString(setting); + builder.putString(setting); } @Override diff --git a/java/src/com/swiftnav/sbp/settings/MsgSettingsRegisterResp.java b/java/src/com/swiftnav/sbp/settings/MsgSettingsRegisterResp.java index 5a38d926d..3499ef6b1 100644 --- a/java/src/com/swiftnav/sbp/settings/MsgSettingsRegisterResp.java +++ b/java/src/com/swiftnav/sbp/settings/MsgSettingsRegisterResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,64 +9,65 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.settings; // This file was auto-generated from yaml/swiftnav/sbp/settings.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SETTINGS_REGISTER_RESP (0x01AF). +/** SBP class for message MSG_SETTINGS_REGISTER_RESP (0x01AF). * - *

You can have MSG_SETTINGS_REGISTER_RESP inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SETTINGS_REGISTER_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message responds to setting registration with the effective value. The effective value - * shall differ from the given default value if setting was already registered or is available in - * the permanent setting storage and had a different value. - */ + * This message responds to setting registration with the effective value. The + * effective value shall differ from the given default value if setting was + * already registered or is available in the permanent setting storage and had + * a different value. */ + public class MsgSettingsRegisterResp extends SBPMessage { public static final int TYPE = 0x01AF; + /** Register status */ public int status; - - /** - * A NULL-terminated and delimited string with contents "SECTION_SETTING\0SETTING\0VALUE". The - * meaning of value is defined according to the status field. - */ + + /** A NULL-terminated and delimited string with contents + * "SECTION_SETTING\0SETTING\0VALUE". The meaning of value is defined + * according to the status field. */ public String setting; + - public MsgSettingsRegisterResp(int sender) { - super(sender, TYPE); - } - - public MsgSettingsRegisterResp() { - super(TYPE); - } - - public MsgSettingsRegisterResp(SBPMessage msg) throws SBPBinaryException { + public MsgSettingsRegisterResp (int sender) { super(sender, TYPE); } + public MsgSettingsRegisterResp () { super(TYPE); } + public MsgSettingsRegisterResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSettingsRegisterResp, expected 431, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSettingsRegisterResp, expected 431, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ status = parser.getU8(); - setting = parser.getString(); + setting = parser.getString(); } @Override protected void build(Builder builder) { builder.putU8(status); - builder.putString(setting); + builder.putString(setting); } @Override diff --git a/java/src/com/swiftnav/sbp/settings/MsgSettingsSave.java b/java/src/com/swiftnav/sbp/settings/MsgSettingsSave.java index 3bcbdb07a..3587e5d88 100644 --- a/java/src/com/swiftnav/sbp/settings/MsgSettingsSave.java +++ b/java/src/com/swiftnav/sbp/settings/MsgSettingsSave.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,41 +9,42 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.settings; // This file was auto-generated from yaml/swiftnav/sbp/settings.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SETTINGS_SAVE (0x00A1). +/** SBP class for message MSG_SETTINGS_SAVE (0x00A1). * - *

You can have MSG_SETTINGS_SAVE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_SETTINGS_SAVE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The save settings message persists the device's current settings configuration to its onboard - * flash memory file system. - */ + * The save settings message persists the device's current settings + * configuration to its onboard flash memory file system. */ + public class MsgSettingsSave extends SBPMessage { public static final int TYPE = 0x00A1; - public MsgSettingsSave(int sender) { - super(sender, TYPE); - } - - public MsgSettingsSave() { - super(TYPE); - } + - public MsgSettingsSave(SBPMessage msg) throws SBPBinaryException { + public MsgSettingsSave (int sender) { super(sender, TYPE); } + public MsgSettingsSave () { super(TYPE); } + public MsgSettingsSave (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSettingsSave, expected 161, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSettingsSave, expected 161, actual " + msg.type); } @Override diff --git a/java/src/com/swiftnav/sbp/settings/MsgSettingsWrite.java b/java/src/com/swiftnav/sbp/settings/MsgSettingsWrite.java index a25096d99..b388a25f4 100644 --- a/java/src/com/swiftnav/sbp/settings/MsgSettingsWrite.java +++ b/java/src/com/swiftnav/sbp/settings/MsgSettingsWrite.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.settings; // This file was auto-generated from yaml/swiftnav/sbp/settings.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SETTINGS_WRITE (0x00A0). +/** SBP class for message MSG_SETTINGS_WRITE (0x00A0). * - *

You can have MSG_SETTINGS_WRITE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_SETTINGS_WRITE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The setting message writes the device configuration for a particular setting via A - * NULL-terminated and NULL-delimited string with contents "SECTION_SETTING\0SETTING\0VALUE\0" where - * the '\0' escape sequence denotes the NULL character and where quotation marks are omitted. A - * device will only process to this message when it is received from sender ID 0x42. An example - * string that could be sent to a device is "solution\0soln_freq\010\0". - */ + * The setting message writes the device configuration for a particular + * setting via A NULL-terminated and NULL-delimited string with contents + * "SECTION_SETTING\0SETTING\0VALUE\0" where the '\0' escape sequence denotes + * the NULL character and where quotation marks are omitted. A device will + * only process to this message when it is received from sender ID 0x42. An + * example string that could be sent to a device is + * "solution\0soln_freq\010\0". */ + public class MsgSettingsWrite extends SBPMessage { public static final int TYPE = 0x00A0; - /** - * A NULL-terminated and NULL-delimited string with contents "SECTION_SETTING\0SETTING\0VALUE\0" - */ + + /** A NULL-terminated and NULL-delimited string with contents + * "SECTION_SETTING\0SETTING\0VALUE\0" */ public String setting; + - public MsgSettingsWrite(int sender) { - super(sender, TYPE); - } - - public MsgSettingsWrite() { - super(TYPE); - } - - public MsgSettingsWrite(SBPMessage msg) throws SBPBinaryException { + public MsgSettingsWrite (int sender) { super(sender, TYPE); } + public MsgSettingsWrite () { super(TYPE); } + public MsgSettingsWrite (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSettingsWrite, expected 160, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSettingsWrite, expected 160, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - setting = parser.getString(); + setting = parser.getString(); } @Override protected void build(Builder builder) { - builder.putString(setting); + builder.putString(setting); } @Override diff --git a/java/src/com/swiftnav/sbp/settings/MsgSettingsWriteResp.java b/java/src/com/swiftnav/sbp/settings/MsgSettingsWriteResp.java index 0a8ab37c2..004ac4e18 100644 --- a/java/src/com/swiftnav/sbp/settings/MsgSettingsWriteResp.java +++ b/java/src/com/swiftnav/sbp/settings/MsgSettingsWriteResp.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,63 +9,66 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.settings; // This file was auto-generated from yaml/swiftnav/sbp/settings.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SETTINGS_WRITE_RESP (0x00AF). +/** SBP class for message MSG_SETTINGS_WRITE_RESP (0x00AF). * - *

You can have MSG_SETTINGS_WRITE_RESP inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SETTINGS_WRITE_RESP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Return the status of a write request with the new value of the setting. If the requested value - * is rejected, the current value will be returned. The string field is a NULL-terminated and - * NULL-delimited string with contents "SECTION_SETTING\0SETTING\0VALUE\0" where the '\0' escape - * sequence denotes the NULL character and where quotation marks are omitted. An example string that - * could be sent from device is "solution\0soln_freq\010\0". - */ + * Return the status of a write request with the new value of the setting. If + * the requested value is rejected, the current value will be returned. The + * string field is a NULL-terminated and NULL-delimited string with contents + * "SECTION_SETTING\0SETTING\0VALUE\0" where the '\0' escape sequence denotes + * the NULL character and where quotation marks are omitted. An example string + * that could be sent from device is "solution\0soln_freq\010\0". */ + public class MsgSettingsWriteResp extends SBPMessage { public static final int TYPE = 0x00AF; + /** Write status */ public int status; - - /** A NULL-terminated and delimited string with contents "SECTION_SETTING\0SETTING\0VALUE\0" */ + + /** A NULL-terminated and delimited string with contents + * "SECTION_SETTING\0SETTING\0VALUE\0" */ public String setting; + - public MsgSettingsWriteResp(int sender) { - super(sender, TYPE); - } - - public MsgSettingsWriteResp() { - super(TYPE); - } - - public MsgSettingsWriteResp(SBPMessage msg) throws SBPBinaryException { + public MsgSettingsWriteResp (int sender) { super(sender, TYPE); } + public MsgSettingsWriteResp () { super(TYPE); } + public MsgSettingsWriteResp (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSettingsWriteResp, expected 175, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSettingsWriteResp, expected 175, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ status = parser.getU8(); - setting = parser.getString(); + setting = parser.getString(); } @Override protected void build(Builder builder) { builder.putU8(status); - builder.putString(setting); + builder.putString(setting); } @Override diff --git a/java/src/com/swiftnav/sbp/signing/ECDSASignature.java b/java/src/com/swiftnav/sbp/signing/ECDSASignature.java index 96f7db7a9..a64bdab11 100644 --- a/java/src/com/swiftnav/sbp/signing/ECDSASignature.java +++ b/java/src/com/swiftnav/sbp/signing/ECDSASignature.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,30 +9,33 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.signing; // This file was auto-generated from yaml/swiftnav/sbp/signing.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; public class ECDSASignature extends SBPStruct { - - /** - * Number of bytes to use of the signature field. The DER encoded signature has a maximum size - * of 72 bytes but can vary between 70 and 72 bytes in length. - */ + + /** Number of bytes to use of the signature field. The DER encoded signature has a + * maximum size of 72 bytes but can vary between 70 and 72 bytes in length. */ public int len; - - /** DER encoded ECDSA signature for the messages using SHA-256 as the digest algorithm. */ + + /** DER encoded ECDSA signature for the messages using SHA-256 as the digest + * algorithm. */ public int[] data; + - public ECDSASignature() {} + public ECDSASignature () {} @Override public ECDSASignature parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/signing/MsgAesCmacSignature.java b/java/src/com/swiftnav/sbp/signing/MsgAesCmacSignature.java index cff48584c..171115c5d 100644 --- a/java/src/com/swiftnav/sbp/signing/MsgAesCmacSignature.java +++ b/java/src/com/swiftnav/sbp/signing/MsgAesCmacSignature.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,73 +9,70 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.signing; // This file was auto-generated from yaml/swiftnav/sbp/signing.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_AES_CMAC_SIGNATURE (0x0C10). +/** SBP class for message MSG_AES_CMAC_SIGNATURE (0x0C10). * - *

You can have MSG_AES_CMAC_SIGNATURE inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_AES_CMAC_SIGNATURE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Digital signature using AES-CMAC 128 algorithm used for data integrity. - */ + * Digital signature using AES-CMAC 128 algorithm used for data integrity. */ + public class MsgAesCmacSignature extends SBPMessage { public static final int TYPE = 0x0C10; - /** - * Signature message counter. Zero indexed and incremented with each signature message. The - * counter will not increment if this message was in response to an on demand request. The - * counter will roll over after 256 messages. Upon connection, the value of the counter may not - * initially be zero. - */ + + /** Signature message counter. Zero indexed and incremented with each + * signature message. The counter will not increment if this message was + * in response to an on demand request. The counter will roll over after + * 256 messages. Upon connection, the value of the counter may not + * initially be zero. */ public int stream_counter; - - /** - * On demand message counter. Zero indexed and incremented with each signature message sent in - * response to an on demand message. The counter will roll over after 256 messages. Upon - * connection, the value of the counter may not initially be zero. - */ + + /** On demand message counter. Zero indexed and incremented with each + * signature message sent in response to an on demand message. The + * counter will roll over after 256 messages. Upon connection, the value + * of the counter may not initially be zero. */ public int on_demand_counter; - + /** The last 4 bytes of the certificate's SHA-1 fingerprint */ public int[] certificate_id; - + /** Signature (CMAC tag value) */ public int[] signature; - + /** Describes the format of the 'signed messages' field below. */ public int flags; - - /** - * CRCs of the messages covered by this signature. For Skylark, which delivers SBP messages - * wrapped in Swift's proprietary RTCM message, these are the 24-bit CRCs from the RTCM message - * framing. For SBP only streams, this will be 16-bit CRCs from the SBP framing. See the `flags` - * field to determine the type of CRCs covered. - */ + + /** CRCs of the messages covered by this signature. For Skylark, which + * delivers SBP messages wrapped in Swift's proprietary RTCM message, + * these are the 24-bit CRCs from the RTCM message framing. For SBP only + * streams, this will be 16-bit CRCs from the SBP framing. See the + * `flags` field to determine the type of CRCs covered. */ public int[] signed_messages; + - public MsgAesCmacSignature(int sender) { - super(sender, TYPE); - } - - public MsgAesCmacSignature() { - super(TYPE); - } - - public MsgAesCmacSignature(SBPMessage msg) throws SBPBinaryException { + public MsgAesCmacSignature (int sender) { super(sender, TYPE); } + public MsgAesCmacSignature () { super(TYPE); } + public MsgAesCmacSignature (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgAesCmacSignature, expected 3088, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgAesCmacSignature, expected 3088, actual " + msg.type); } @Override @@ -85,7 +83,7 @@ protected void parse(Parser parser) throws SBPBinaryException { certificate_id = parser.getArrayofU8(4); signature = parser.getArrayofU8(16); flags = parser.getU8(); - signed_messages = parser.getArrayofU8(); + signed_messages = parser.getArrayofU8(); } @Override @@ -95,7 +93,7 @@ protected void build(Builder builder) { builder.putArrayofU8(certificate_id, 4); builder.putArrayofU8(signature, 16); builder.putU8(flags); - builder.putArrayofU8(signed_messages); + builder.putArrayofU8(signed_messages); } @Override diff --git a/java/src/com/swiftnav/sbp/signing/MsgCertificateChain.java b/java/src/com/swiftnav/sbp/signing/MsgCertificateChain.java index 91dbaf13d..86cf06348 100644 --- a/java/src/com/swiftnav/sbp/signing/MsgCertificateChain.java +++ b/java/src/com/swiftnav/sbp/signing/MsgCertificateChain.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,58 +9,57 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.signing; // This file was auto-generated from yaml/swiftnav/sbp/signing.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgCertificateChain extends SBPMessage { public static final int TYPE = 0x0C09; + /** SHA-1 fingerprint of the root certificate */ public int[] root_certificate; - + /** SHA-1 fingerprint of the intermediate certificate */ public int[] intermediate_certificate; - + /** SHA-1 fingerprint of the corrections certificate */ public int[] corrections_certificate; - - /** - * The time after which the signature given is no longer valid. Implementors should consult a - * time source (such as GNSS) to check if the current time is later than the expiration time, if - * the condition is true, signatures in the stream should not be considered valid. - */ + + /** The time after which the signature given is no longer valid. + * Implementors should consult a time source (such as GNSS) to check if + * the current time is later than the expiration time, if the condition + * is true, signatures in the stream should not be considered valid. */ public UtcTime expiration; - - /** - * Signature (created by the root certificate) over the concatenation of the SBP payload bytes - * preceding this field. That is, the concatenation of `root_certificate`, - * `intermediate_certificate`, `corrections_certificate` and `expiration`. This certificate - * chain (allow list) can also be validated by fetching it from - * `http(s)://certs.swiftnav.com/chain`. - */ + + /** Signature (created by the root certificate) over the concatenation of + * the SBP payload bytes preceding this field. That is, the concatenation + * of `root_certificate`, `intermediate_certificate`, + * `corrections_certificate` and `expiration`. This certificate chain + * (allow list) can also be validated by fetching it from + * `http(s)://certs.swiftnav.com/chain`. */ public ECDSASignature signature; + - public MsgCertificateChain(int sender) { - super(sender, TYPE); - } - - public MsgCertificateChain() { - super(TYPE); - } - - public MsgCertificateChain(SBPMessage msg) throws SBPBinaryException { + public MsgCertificateChain (int sender) { super(sender, TYPE); } + public MsgCertificateChain () { super(TYPE); } + public MsgCertificateChain (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgCertificateChain, expected 3081, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgCertificateChain, expected 3081, actual " + msg.type); } @Override @@ -69,7 +69,7 @@ protected void parse(Parser parser) throws SBPBinaryException { intermediate_certificate = parser.getArrayofU8(20); corrections_certificate = parser.getArrayofU8(20); expiration = new UtcTime().parse(parser); - signature = new ECDSASignature().parse(parser); + signature = new ECDSASignature().parse(parser); } @Override @@ -78,7 +78,7 @@ protected void build(Builder builder) { builder.putArrayofU8(intermediate_certificate, 20); builder.putArrayofU8(corrections_certificate, 20); expiration.build(builder); - signature.build(builder); + signature.build(builder); } @Override diff --git a/java/src/com/swiftnav/sbp/signing/MsgCertificateChainDep.java b/java/src/com/swiftnav/sbp/signing/MsgCertificateChainDep.java index 026ba073b..2ff43ed6c 100644 --- a/java/src/com/swiftnav/sbp/signing/MsgCertificateChainDep.java +++ b/java/src/com/swiftnav/sbp/signing/MsgCertificateChainDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,65 +9,62 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.signing; // This file was auto-generated from yaml/swiftnav/sbp/signing.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_CERTIFICATE_CHAIN_DEP (0x0C05). +/** SBP class for message MSG_CERTIFICATE_CHAIN_DEP (0x0C05). * - *

You can have MSG_CERTIFICATE_CHAIN_DEP inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_CERTIFICATE_CHAIN_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgCertificateChainDep extends SBPMessage { public static final int TYPE = 0x0C05; + /** SHA-1 fingerprint of the root certificate */ public int[] root_certificate; - + /** SHA-1 fingerprint of the intermediate certificate */ public int[] intermediate_certificate; - + /** SHA-1 fingerprint of the corrections certificate */ public int[] corrections_certificate; - - /** - * The certificate chain comprised of three fingerprints: root certificate, intermediate - * certificate and corrections certificate. - */ + + /** The certificate chain comprised of three fingerprints: root + * certificate, intermediate certificate and corrections certificate. */ public UtcTime expiration; - - /** - * An ECDSA signature (created by the root certificate) over the concatenation of the SBP - * payload bytes preceding this field. That is, the concatenation of `root_certificate`, - * `intermediate_certificate`, `corrections_certificate` and `expiration`. This certificate - * chain (allow list) can also be validated by fetching it from - * `http(s)://certs.swiftnav.com/chain`. - */ + + /** An ECDSA signature (created by the root certificate) over the + * concatenation of the SBP payload bytes preceding this field. That is, + * the concatenation of `root_certificate`, `intermediate_certificate`, + * `corrections_certificate` and `expiration`. This certificate chain + * (allow list) can also be validated by fetching it from + * `http(s)://certs.swiftnav.com/chain`. */ public int[] signature; + - public MsgCertificateChainDep(int sender) { - super(sender, TYPE); - } - - public MsgCertificateChainDep() { - super(TYPE); - } - - public MsgCertificateChainDep(SBPMessage msg) throws SBPBinaryException { + public MsgCertificateChainDep (int sender) { super(sender, TYPE); } + public MsgCertificateChainDep () { super(TYPE); } + public MsgCertificateChainDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgCertificateChainDep, expected 3077, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgCertificateChainDep, expected 3077, actual " + msg.type); } @Override @@ -76,7 +74,7 @@ protected void parse(Parser parser) throws SBPBinaryException { intermediate_certificate = parser.getArrayofU8(20); corrections_certificate = parser.getArrayofU8(20); expiration = new UtcTime().parse(parser); - signature = parser.getArrayofU8(64); + signature = parser.getArrayofU8(64); } @Override @@ -85,7 +83,7 @@ protected void build(Builder builder) { builder.putArrayofU8(intermediate_certificate, 20); builder.putArrayofU8(corrections_certificate, 20); expiration.build(builder); - builder.putArrayofU8(signature, 64); + builder.putArrayofU8(signature, 64); } @Override diff --git a/java/src/com/swiftnav/sbp/signing/MsgEcdsaCertificate.java b/java/src/com/swiftnav/sbp/signing/MsgEcdsaCertificate.java index ce8c700b4..f3f048081 100644 --- a/java/src/com/swiftnav/sbp/signing/MsgEcdsaCertificate.java +++ b/java/src/com/swiftnav/sbp/signing/MsgEcdsaCertificate.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,55 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.signing; // This file was auto-generated from yaml/swiftnav/sbp/signing.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_ECDSA_CERTIFICATE (0x0C04). + +/** SBP class for message MSG_ECDSA_CERTIFICATE (0x0C04). * - *

You can have MSG_ECDSA_CERTIFICATE inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_ECDSA_CERTIFICATE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

A DER encoded x.509 ECDSA-256 certificate (using curve secp256r1). - */ + * A DER encoded x.509 ECDSA-256 certificate (using curve secp256r1). */ + public class MsgEcdsaCertificate extends SBPMessage { public static final int TYPE = 0x0C04; - /** - * Total number messages that make up the certificate. The first nibble (mask 0xF0 or left - * shifted by 4 bits) is the size of the sequence (n), second nibble (mask 0x0F) is the - * zero-indexed counter (ith packet of n). - */ + + /** Total number messages that make up the certificate. The first nibble + * (mask 0xF0 or left shifted by 4 bits) is the size of the sequence (n), + * second nibble (mask 0x0F) is the zero-indexed counter (ith packet of + * n). */ public int n_msg; - + /** The last 4 bytes of the certificate's SHA-1 fingerprint */ public int[] certificate_id; - + public int flags; - + /** DER encoded x.509 ECDSA certificate bytes */ public int[] certificate_bytes; + - public MsgEcdsaCertificate(int sender) { - super(sender, TYPE); - } - - public MsgEcdsaCertificate() { - super(TYPE); - } - - public MsgEcdsaCertificate(SBPMessage msg) throws SBPBinaryException { + public MsgEcdsaCertificate (int sender) { super(sender, TYPE); } + public MsgEcdsaCertificate () { super(TYPE); } + public MsgEcdsaCertificate (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEcdsaCertificate, expected 3076, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEcdsaCertificate, expected 3076, actual " + msg.type); } @Override @@ -66,7 +66,7 @@ protected void parse(Parser parser) throws SBPBinaryException { n_msg = parser.getU8(); certificate_id = parser.getArrayofU8(4); flags = parser.getU8(); - certificate_bytes = parser.getArrayofU8(); + certificate_bytes = parser.getArrayofU8(); } @Override @@ -74,7 +74,7 @@ protected void build(Builder builder) { builder.putU8(n_msg); builder.putArrayofU8(certificate_id, 4); builder.putU8(flags); - builder.putArrayofU8(certificate_bytes); + builder.putArrayofU8(certificate_bytes); } @Override diff --git a/java/src/com/swiftnav/sbp/signing/MsgEcdsaSignature.java b/java/src/com/swiftnav/sbp/signing/MsgEcdsaSignature.java index 73dba9344..76a87dae6 100644 --- a/java/src/com/swiftnav/sbp/signing/MsgEcdsaSignature.java +++ b/java/src/com/swiftnav/sbp/signing/MsgEcdsaSignature.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,73 +9,70 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.signing; // This file was auto-generated from yaml/swiftnav/sbp/signing.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ECDSA_SIGNATURE (0x0C08). +/** SBP class for message MSG_ECDSA_SIGNATURE (0x0C08). * - *

You can have MSG_ECDSA_SIGNATURE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_ECDSA_SIGNATURE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

An ECDSA-256 signature using SHA-256 as the message digest algorithm. - */ + * An ECDSA-256 signature using SHA-256 as the message digest algorithm. */ + public class MsgEcdsaSignature extends SBPMessage { public static final int TYPE = 0x0C08; + /** Describes the format of the `signed\_messages` field below. */ public int flags; - - /** - * Signature message counter. Zero indexed and incremented with each signature message. The - * counter will not increment if this message was in response to an on demand request. The - * counter will roll over after 256 messages. Upon connection, the value of the counter may not - * initially be zero. - */ + + /** Signature message counter. Zero indexed and incremented with each + * signature message. The counter will not increment if this message was + * in response to an on demand request. The counter will roll over after + * 256 messages. Upon connection, the value of the counter may not + * initially be zero. */ public int stream_counter; - - /** - * On demand message counter. Zero indexed and incremented with each signature message sent in - * response to an on demand message. The counter will roll over after 256 messages. Upon - * connection, the value of the counter may not initially be zero. - */ + + /** On demand message counter. Zero indexed and incremented with each + * signature message sent in response to an on demand message. The + * counter will roll over after 256 messages. Upon connection, the value + * of the counter may not initially be zero. */ public int on_demand_counter; - + /** The last 4 bytes of the certificate's SHA-1 fingerprint */ public int[] certificate_id; - + /** Signature over the frames of this message group. */ public ECDSASignature signature; - - /** - * CRCs of the messages covered by this signature. For Skylark, which delivers SBP messages - * wrapped in Swift's proprietary RTCM message, these are the 24-bit CRCs from the RTCM message - * framing. For SBP only streams, this will be 16-bit CRCs from the SBP framing. See the `flags` - * field to determine the type of CRCs covered. - */ + + /** CRCs of the messages covered by this signature. For Skylark, which + * delivers SBP messages wrapped in Swift's proprietary RTCM message, + * these are the 24-bit CRCs from the RTCM message framing. For SBP only + * streams, this will be 16-bit CRCs from the SBP framing. See the + * `flags` field to determine the type of CRCs covered. */ public int[] signed_messages; + - public MsgEcdsaSignature(int sender) { - super(sender, TYPE); - } - - public MsgEcdsaSignature() { - super(TYPE); - } - - public MsgEcdsaSignature(SBPMessage msg) throws SBPBinaryException { + public MsgEcdsaSignature (int sender) { super(sender, TYPE); } + public MsgEcdsaSignature () { super(TYPE); } + public MsgEcdsaSignature (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEcdsaSignature, expected 3080, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEcdsaSignature, expected 3080, actual " + msg.type); } @Override @@ -85,7 +83,7 @@ protected void parse(Parser parser) throws SBPBinaryException { on_demand_counter = parser.getU8(); certificate_id = parser.getArrayofU8(4); signature = new ECDSASignature().parse(parser); - signed_messages = parser.getArrayofU8(); + signed_messages = parser.getArrayofU8(); } @Override @@ -95,7 +93,7 @@ protected void build(Builder builder) { builder.putU8(on_demand_counter); builder.putArrayofU8(certificate_id, 4); signature.build(builder); - builder.putArrayofU8(signed_messages); + builder.putArrayofU8(signed_messages); } @Override diff --git a/java/src/com/swiftnav/sbp/signing/MsgEcdsaSignatureDepA.java b/java/src/com/swiftnav/sbp/signing/MsgEcdsaSignatureDepA.java index ea41f0f54..52601b7c7 100644 --- a/java/src/com/swiftnav/sbp/signing/MsgEcdsaSignatureDepA.java +++ b/java/src/com/swiftnav/sbp/signing/MsgEcdsaSignatureDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,73 +9,71 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.signing; // This file was auto-generated from yaml/swiftnav/sbp/signing.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ECDSA_SIGNATURE_DEP_A (0x0C06). +/** SBP class for message MSG_ECDSA_SIGNATURE_DEP_A (0x0C06). * - *

You can have MSG_ECDSA_SIGNATURE_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_ECDSA_SIGNATURE_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEcdsaSignatureDepA extends SBPMessage { public static final int TYPE = 0x0C06; + /** Describes the format of the `signed\_messages` field below. */ public int flags; - - /** - * Signature message counter. Zero indexed and incremented with each signature message. The - * counter will not increment if this message was in response to an on demand request. The - * counter will roll over after 256 messages. Upon connection, the value of the counter may not - * initially be zero. - */ + + /** Signature message counter. Zero indexed and incremented with each + * signature message. The counter will not increment if this message was + * in response to an on demand request. The counter will roll over after + * 256 messages. Upon connection, the value of the counter may not + * initially be zero. */ public int stream_counter; - - /** - * On demand message counter. Zero indexed and incremented with each signature message sent in - * response to an on demand message. The counter will roll over after 256 messages. Upon - * connection, the value of the counter may not initially be zero. - */ + + /** On demand message counter. Zero indexed and incremented with each + * signature message sent in response to an on demand message. The + * counter will roll over after 256 messages. Upon connection, the value + * of the counter may not initially be zero. */ public int on_demand_counter; - + /** The last 4 bytes of the certificate's SHA-1 fingerprint */ public int[] certificate_id; - - /** ECDSA signature for the messages using SHA-256 as the digest algorithm. */ + + /** ECDSA signature for the messages using SHA-256 as the digest + * algorithm. */ public int[] signature; - - /** - * CRCs of the messages covered by this signature. For Skylark, which delivers SBP messages - * wrapped in Swift's proprietary RTCM message, these are the 24-bit CRCs from the RTCM message - * framing. For SBP only streams, this will be 16-bit CRCs from the SBP framing. See the `flags` - * field to determine the type of CRCs covered. - */ + + /** CRCs of the messages covered by this signature. For Skylark, which + * delivers SBP messages wrapped in Swift's proprietary RTCM message, + * these are the 24-bit CRCs from the RTCM message framing. For SBP only + * streams, this will be 16-bit CRCs from the SBP framing. See the + * `flags` field to determine the type of CRCs covered. */ public int[] signed_messages; + - public MsgEcdsaSignatureDepA(int sender) { - super(sender, TYPE); - } - - public MsgEcdsaSignatureDepA() { - super(TYPE); - } - - public MsgEcdsaSignatureDepA(SBPMessage msg) throws SBPBinaryException { + public MsgEcdsaSignatureDepA (int sender) { super(sender, TYPE); } + public MsgEcdsaSignatureDepA () { super(TYPE); } + public MsgEcdsaSignatureDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEcdsaSignatureDepA, expected 3078, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEcdsaSignatureDepA, expected 3078, actual " + msg.type); } @Override @@ -85,7 +84,7 @@ protected void parse(Parser parser) throws SBPBinaryException { on_demand_counter = parser.getU8(); certificate_id = parser.getArrayofU8(4); signature = parser.getArrayofU8(64); - signed_messages = parser.getArrayofU8(); + signed_messages = parser.getArrayofU8(); } @Override @@ -95,7 +94,7 @@ protected void build(Builder builder) { builder.putU8(on_demand_counter); builder.putArrayofU8(certificate_id, 4); builder.putArrayofU8(signature, 64); - builder.putArrayofU8(signed_messages); + builder.putArrayofU8(signed_messages); } @Override diff --git a/java/src/com/swiftnav/sbp/signing/MsgEcdsaSignatureDepB.java b/java/src/com/swiftnav/sbp/signing/MsgEcdsaSignatureDepB.java index d671fd473..45e838127 100644 --- a/java/src/com/swiftnav/sbp/signing/MsgEcdsaSignatureDepB.java +++ b/java/src/com/swiftnav/sbp/signing/MsgEcdsaSignatureDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,79 +9,76 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.signing; // This file was auto-generated from yaml/swiftnav/sbp/signing.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ECDSA_SIGNATURE_DEP_B (0x0C07). +/** SBP class for message MSG_ECDSA_SIGNATURE_DEP_B (0x0C07). * - *

You can have MSG_ECDSA_SIGNATURE_DEP_B inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_ECDSA_SIGNATURE_DEP_B inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEcdsaSignatureDepB extends SBPMessage { public static final int TYPE = 0x0C07; + /** Describes the format of the `signed\_messages` field below. */ public int flags; - - /** - * Signature message counter. Zero indexed and incremented with each signature message. The - * counter will not increment if this message was in response to an on demand request. The - * counter will roll over after 256 messages. Upon connection, the value of the counter may not - * initially be zero. - */ + + /** Signature message counter. Zero indexed and incremented with each + * signature message. The counter will not increment if this message was + * in response to an on demand request. The counter will roll over after + * 256 messages. Upon connection, the value of the counter may not + * initially be zero. */ public int stream_counter; - - /** - * On demand message counter. Zero indexed and incremented with each signature message sent in - * response to an on demand message. The counter will roll over after 256 messages. Upon - * connection, the value of the counter may not initially be zero. - */ + + /** On demand message counter. Zero indexed and incremented with each + * signature message sent in response to an on demand message. The + * counter will roll over after 256 messages. Upon connection, the value + * of the counter may not initially be zero. */ public int on_demand_counter; - + /** The last 4 bytes of the certificate's SHA-1 fingerprint */ public int[] certificate_id; - - /** - * Number of bytes to use of the signature field. The DER encoded signature has a maximum size - * of 72 bytes but can vary between 70 and 72 bytes in length. - */ + + /** Number of bytes to use of the signature field. The DER encoded + * signature has a maximum size of 72 bytes but can vary between 70 and + * 72 bytes in length. */ public int n_signature_bytes; - - /** DER encoded ECDSA signature for the messages using SHA-256 as the digest algorithm. */ + + /** DER encoded ECDSA signature for the messages using SHA-256 as the + * digest algorithm. */ public int[] signature; - - /** - * CRCs of the messages covered by this signature. For Skylark, which delivers SBP messages - * wrapped in Swift's proprietary RTCM message, these are the 24-bit CRCs from the RTCM message - * framing. For SBP only streams, this will be 16-bit CRCs from the SBP framing. See the `flags` - * field to determine the type of CRCs covered. - */ + + /** CRCs of the messages covered by this signature. For Skylark, which + * delivers SBP messages wrapped in Swift's proprietary RTCM message, + * these are the 24-bit CRCs from the RTCM message framing. For SBP only + * streams, this will be 16-bit CRCs from the SBP framing. See the + * `flags` field to determine the type of CRCs covered. */ public int[] signed_messages; + - public MsgEcdsaSignatureDepB(int sender) { - super(sender, TYPE); - } - - public MsgEcdsaSignatureDepB() { - super(TYPE); - } - - public MsgEcdsaSignatureDepB(SBPMessage msg) throws SBPBinaryException { + public MsgEcdsaSignatureDepB (int sender) { super(sender, TYPE); } + public MsgEcdsaSignatureDepB () { super(TYPE); } + public MsgEcdsaSignatureDepB (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEcdsaSignatureDepB, expected 3079, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEcdsaSignatureDepB, expected 3079, actual " + msg.type); } @Override @@ -92,7 +90,7 @@ protected void parse(Parser parser) throws SBPBinaryException { certificate_id = parser.getArrayofU8(4); n_signature_bytes = parser.getU8(); signature = parser.getArrayofU8(72); - signed_messages = parser.getArrayofU8(); + signed_messages = parser.getArrayofU8(); } @Override @@ -103,7 +101,7 @@ protected void build(Builder builder) { builder.putArrayofU8(certificate_id, 4); builder.putU8(n_signature_bytes); builder.putArrayofU8(signature, 72); - builder.putArrayofU8(signed_messages); + builder.putArrayofU8(signed_messages); } @Override diff --git a/java/src/com/swiftnav/sbp/signing/MsgEd25519CertificateDep.java b/java/src/com/swiftnav/sbp/signing/MsgEd25519CertificateDep.java index 0e87aa946..f4d968fe1 100644 --- a/java/src/com/swiftnav/sbp/signing/MsgEd25519CertificateDep.java +++ b/java/src/com/swiftnav/sbp/signing/MsgEd25519CertificateDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,54 +9,52 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.signing; // This file was auto-generated from yaml/swiftnav/sbp/signing.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_ED25519_CERTIFICATE_DEP (0x0C02). + +/** SBP class for message MSG_ED25519_CERTIFICATE_DEP (0x0C02). * - *

You can have MSG_ED25519_CERTIFICATE_DEP inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_ED25519_CERTIFICATE_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEd25519CertificateDep extends SBPMessage { public static final int TYPE = 0x0C02; - /** - * Total number messages that make up the certificate. First nibble is the size of the sequence - * (n), second nibble is the zero-indexed counter (ith packet of n) - */ + + /** Total number messages that make up the certificate. First nibble is + * the size of the sequence (n), second nibble is the zero-indexed + * counter (ith packet of n) */ public int n_msg; - + /** SHA-1 fingerprint of the associated certificate. */ public int[] fingerprint; - + /** ED25519 certificate bytes. */ public int[] certificate_bytes; + - public MsgEd25519CertificateDep(int sender) { - super(sender, TYPE); - } - - public MsgEd25519CertificateDep() { - super(TYPE); - } - - public MsgEd25519CertificateDep(SBPMessage msg) throws SBPBinaryException { + public MsgEd25519CertificateDep (int sender) { super(sender, TYPE); } + public MsgEd25519CertificateDep () { super(TYPE); } + public MsgEd25519CertificateDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEd25519CertificateDep, expected 3074, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEd25519CertificateDep, expected 3074, actual " + msg.type); } @Override @@ -63,14 +62,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ n_msg = parser.getU8(); fingerprint = parser.getArrayofU8(20); - certificate_bytes = parser.getArrayofU8(); + certificate_bytes = parser.getArrayofU8(); } @Override protected void build(Builder builder) { builder.putU8(n_msg); builder.putArrayofU8(fingerprint, 20); - builder.putArrayofU8(certificate_bytes); + builder.putArrayofU8(certificate_bytes); } @Override diff --git a/java/src/com/swiftnav/sbp/signing/MsgEd25519SignatureDepA.java b/java/src/com/swiftnav/sbp/signing/MsgEd25519SignatureDepA.java index 165bfdf56..b25954a72 100644 --- a/java/src/com/swiftnav/sbp/signing/MsgEd25519SignatureDepA.java +++ b/java/src/com/swiftnav/sbp/signing/MsgEd25519SignatureDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,50 +9,50 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.signing; // This file was auto-generated from yaml/swiftnav/sbp/signing.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_ED25519_SIGNATURE_DEP_A (0x0C01). + +/** SBP class for message MSG_ED25519_SIGNATURE_DEP_A (0x0C01). * - *

You can have MSG_ED25519_SIGNATURE_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_ED25519_SIGNATURE_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEd25519SignatureDepA extends SBPMessage { public static final int TYPE = 0x0C01; + /** ED25519 signature for messages. */ public int[] signature; - + /** SHA-1 fingerprint of the associated certificate. */ public int[] fingerprint; - + /** CRCs of signed messages. */ public long[] signed_messages; + - public MsgEd25519SignatureDepA(int sender) { - super(sender, TYPE); - } - - public MsgEd25519SignatureDepA() { - super(TYPE); - } - - public MsgEd25519SignatureDepA(SBPMessage msg) throws SBPBinaryException { + public MsgEd25519SignatureDepA (int sender) { super(sender, TYPE); } + public MsgEd25519SignatureDepA () { super(TYPE); } + public MsgEd25519SignatureDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEd25519SignatureDepA, expected 3073, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEd25519SignatureDepA, expected 3073, actual " + msg.type); } @Override @@ -59,14 +60,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ signature = parser.getArrayofU8(64); fingerprint = parser.getArrayofU8(20); - signed_messages = parser.getArrayofU32(); + signed_messages = parser.getArrayofU32(); } @Override protected void build(Builder builder) { builder.putArrayofU8(signature, 64); builder.putArrayofU8(fingerprint, 20); - builder.putArrayofU32(signed_messages); + builder.putArrayofU32(signed_messages); } @Override diff --git a/java/src/com/swiftnav/sbp/signing/MsgEd25519SignatureDepB.java b/java/src/com/swiftnav/sbp/signing/MsgEd25519SignatureDepB.java index a9450da00..0e2c2284b 100644 --- a/java/src/com/swiftnav/sbp/signing/MsgEd25519SignatureDepB.java +++ b/java/src/com/swiftnav/sbp/signing/MsgEd25519SignatureDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,65 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.signing; // This file was auto-generated from yaml/swiftnav/sbp/signing.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_ED25519_SIGNATURE_DEP_B (0x0C03). +/** SBP class for message MSG_ED25519_SIGNATURE_DEP_B (0x0C03). * - *

You can have MSG_ED25519_SIGNATURE_DEP_B inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_ED25519_SIGNATURE_DEP_B inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgEd25519SignatureDepB extends SBPMessage { public static final int TYPE = 0x0C03; - /** - * Signature message counter. Zero indexed and incremented with each signature message. The - * counter will not increment if this message was in response to an on demand request. The - * counter will roll over after 256 messages. Upon connection, the value of the counter may not - * initially be zero. - */ + + /** Signature message counter. Zero indexed and incremented with each + * signature message. The counter will not increment if this message was + * in response to an on demand request. The counter will roll over after + * 256 messages. Upon connection, the value of the counter may not + * initially be zero. */ public int stream_counter; - - /** - * On demand message counter. Zero indexed and incremented with each signature message sent in - * response to an on demand message. The counter will roll over after 256 messages. Upon - * connection, the value of the counter may not initially be zero. - */ + + /** On demand message counter. Zero indexed and incremented with each + * signature message sent in response to an on demand message. The + * counter will roll over after 256 messages. Upon connection, the value + * of the counter may not initially be zero. */ public int on_demand_counter; - + /** ED25519 signature for messages. */ public int[] signature; - + /** SHA-1 fingerprint of the associated certificate. */ public int[] fingerprint; - + /** CRCs of signed messages. */ public long[] signed_messages; + - public MsgEd25519SignatureDepB(int sender) { - super(sender, TYPE); - } - - public MsgEd25519SignatureDepB() { - super(TYPE); - } - - public MsgEd25519SignatureDepB(SBPMessage msg) throws SBPBinaryException { + public MsgEd25519SignatureDepB (int sender) { super(sender, TYPE); } + public MsgEd25519SignatureDepB () { super(TYPE); } + public MsgEd25519SignatureDepB (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgEd25519SignatureDepB, expected 3075, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgEd25519SignatureDepB, expected 3075, actual " + msg.type); } @Override @@ -76,7 +75,7 @@ protected void parse(Parser parser) throws SBPBinaryException { on_demand_counter = parser.getU8(); signature = parser.getArrayofU8(64); fingerprint = parser.getArrayofU8(20); - signed_messages = parser.getArrayofU32(); + signed_messages = parser.getArrayofU32(); } @Override @@ -85,7 +84,7 @@ protected void build(Builder builder) { builder.putU8(on_demand_counter); builder.putArrayofU8(signature, 64); builder.putArrayofU8(fingerprint, 20); - builder.putArrayofU32(signed_messages); + builder.putArrayofU32(signed_messages); } @Override diff --git a/java/src/com/swiftnav/sbp/signing/UtcTime.java b/java/src/com/swiftnav/sbp/signing/UtcTime.java index d0d7f3519..4b688d35e 100644 --- a/java/src/com/swiftnav/sbp/signing/UtcTime.java +++ b/java/src/com/swiftnav/sbp/signing/UtcTime.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,41 +9,46 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.signing; // This file was auto-generated from yaml/swiftnav/sbp/signing.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class UtcTime extends SBPStruct { - + /** Year */ public int year; - + /** Month (range 1 .. 12) */ public int month; - + /** days in the month (range 1-31) */ public int day; - + /** hours of day (range 0-23) */ public int hours; - + /** minutes of hour (range 0-59) */ public int minutes; - + /** seconds of minute (range 0-60) rounded down */ public int seconds; - + /** nanoseconds of second (range 0-999999999) */ public long ns; + - public UtcTime() {} + public UtcTime () {} @Override public UtcTime parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/solution_meta/GNSSInputType.java b/java/src/com/swiftnav/sbp/solution_meta/GNSSInputType.java index 74c8a9627..5e006f230 100644 --- a/java/src/com/swiftnav/sbp/solution_meta/GNSSInputType.java +++ b/java/src/com/swiftnav/sbp/solution_meta/GNSSInputType.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,23 +9,28 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.solution_meta; // This file was auto-generated from yaml/swiftnav/sbp/solution_meta.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class GNSSInputType extends SBPStruct { - + /** flags that store all relevant info specific to this sensor type. */ public int flags; + - public GNSSInputType() {} + public GNSSInputType () {} @Override public GNSSInputType parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/solution_meta/IMUInputType.java b/java/src/com/swiftnav/sbp/solution_meta/IMUInputType.java index 4fffbb170..40fba11b9 100644 --- a/java/src/com/swiftnav/sbp/solution_meta/IMUInputType.java +++ b/java/src/com/swiftnav/sbp/solution_meta/IMUInputType.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,23 +9,28 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.solution_meta; // This file was auto-generated from yaml/swiftnav/sbp/solution_meta.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class IMUInputType extends SBPStruct { - + /** Instrument time, grade, and architecture for a sensor. */ public int flags; + - public IMUInputType() {} + public IMUInputType () {} @Override public IMUInputType parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/solution_meta/MsgSolnMeta.java b/java/src/com/swiftnav/sbp/solution_meta/MsgSolnMeta.java index 37febc4fc..14851a089 100644 --- a/java/src/com/swiftnav/sbp/solution_meta/MsgSolnMeta.java +++ b/java/src/com/swiftnav/sbp/solution_meta/MsgSolnMeta.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,85 +9,78 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.solution_meta; // This file was auto-generated from yaml/swiftnav/sbp/solution_meta.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SOLN_META (0xFF0E). +/** SBP class for message MSG_SOLN_META (0xFF0E). * - *

You can have MSG_SOLN_META inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_SOLN_META inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message contains all metadata about the sensors received and/or used in computing the - * sensorfusion solution. It focuses primarily, but not only, on GNSS metadata. Regarding the age of - * the last received valid GNSS solution, the highest two bits are time status, indicating whether - * age gnss can or can not be used to retrieve time of measurement (noted TOM, also known as time of - * validity) If it can, subtract 'age gnss' from 'tow' in navigation messages to get TOM. Can be - * used before alignment is complete in the Fusion Engine, when output solution is the last received - * valid GNSS solution and its tow is not a TOM. - */ + * This message contains all metadata about the sensors received and/or used + * in computing the sensorfusion solution. It focuses primarily, but not only, + * on GNSS metadata. Regarding the age of the last received valid GNSS + * solution, the highest two bits are time status, indicating whether age gnss + * can or can not be used to retrieve time of measurement (noted TOM, also + * known as time of validity) If it can, subtract 'age gnss' from 'tow' in + * navigation messages to get TOM. Can be used before alignment is complete in + * the Fusion Engine, when output solution is the last received valid GNSS + * solution and its tow is not a TOM. */ + public class MsgSolnMeta extends SBPMessage { public static final int TYPE = 0xFF0E; + /** GPS time of week rounded to the nearest millisecond */ public long tow; - - /** - * Position Dilution of Precision as per last available DOPS from PVT engine (0xFFFF indicates - * invalid) - */ + + /** Position Dilution of Precision as per last available DOPS from PVT + * engine (0xFFFF indicates invalid) */ public int pdop; - - /** - * Horizontal Dilution of Precision as per last available DOPS from PVT engine (0xFFFF indicates - * invalid) - */ + + /** Horizontal Dilution of Precision as per last available DOPS from PVT + * engine (0xFFFF indicates invalid) */ public int hdop; - - /** - * Vertical Dilution of Precision as per last available DOPS from PVT engine (0xFFFF indicates - * invalid) - */ + + /** Vertical Dilution of Precision as per last available DOPS from PVT + * engine (0xFFFF indicates invalid) */ public int vdop; - - /** - * Age of corrections as per last available AGE_CORRECTIONS from PVT engine (0xFFFF indicates - * invalid) - */ + + /** Age of corrections as per last available AGE_CORRECTIONS from PVT + * engine (0xFFFF indicates invalid) */ public int age_corrections; - + /** Age and Time Status of the last received valid GNSS solution. */ public long age_gnss; - - /** - * Array of Metadata describing the sensors potentially involved in the solution. Each element - * in the array represents a single sensor type and consists of flags containing (meta)data - * pertaining to that specific single sensor. Refer to each (XX)InputType descriptor in the - * present doc. - */ + + /** Array of Metadata describing the sensors potentially involved in the + * solution. Each element in the array represents a single sensor type + * and consists of flags containing (meta)data pertaining to that + * specific single sensor. Refer to each (XX)InputType descriptor in the + * present doc. */ public SolutionInputType[] sol_in; + - public MsgSolnMeta(int sender) { - super(sender, TYPE); - } - - public MsgSolnMeta() { - super(TYPE); - } - - public MsgSolnMeta(SBPMessage msg) throws SBPBinaryException { + public MsgSolnMeta (int sender) { super(sender, TYPE); } + public MsgSolnMeta () { super(TYPE); } + public MsgSolnMeta (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSolnMeta, expected 65294, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSolnMeta, expected 65294, actual " + msg.type); } @Override @@ -98,7 +92,7 @@ protected void parse(Parser parser) throws SBPBinaryException { vdop = parser.getU16(); age_corrections = parser.getU16(); age_gnss = parser.getU32(); - sol_in = parser.getArray(SolutionInputType.class); + sol_in = parser.getArray(SolutionInputType.class); } @Override @@ -109,7 +103,7 @@ protected void build(Builder builder) { builder.putU16(vdop); builder.putU16(age_corrections); builder.putU32(age_gnss); - builder.putArray(sol_in); + builder.putArray(sol_in); } @Override diff --git a/java/src/com/swiftnav/sbp/solution_meta/MsgSolnMetaDepA.java b/java/src/com/swiftnav/sbp/solution_meta/MsgSolnMetaDepA.java index 7ed0f889b..5f7e45acd 100644 --- a/java/src/com/swiftnav/sbp/solution_meta/MsgSolnMetaDepA.java +++ b/java/src/com/swiftnav/sbp/solution_meta/MsgSolnMetaDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,85 +9,76 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.solution_meta; // This file was auto-generated from yaml/swiftnav/sbp/solution_meta.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SOLN_META_DEP_A (0xFF0F). +/** SBP class for message MSG_SOLN_META_DEP_A (0xFF0F). * - *

You can have MSG_SOLN_META_DEP_A inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_SOLN_META_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSolnMetaDepA extends SBPMessage { public static final int TYPE = 0xFF0F; - /** - * Position Dilution of Precision as per last available DOPS from PVT engine (0xFFFF indicates - * invalid) - */ + + /** Position Dilution of Precision as per last available DOPS from PVT + * engine (0xFFFF indicates invalid) */ public int pdop; - - /** - * Horizontal Dilution of Precision as per last available DOPS from PVT engine (0xFFFF indicates - * invalid) - */ + + /** Horizontal Dilution of Precision as per last available DOPS from PVT + * engine (0xFFFF indicates invalid) */ public int hdop; - - /** - * Vertical Dilution of Precision as per last available DOPS from PVT engine (0xFFFF indicates - * invalid) - */ + + /** Vertical Dilution of Precision as per last available DOPS from PVT + * engine (0xFFFF indicates invalid) */ public int vdop; - + /** Number of satellites as per last available solution from PVT engine */ public int n_sats; - - /** - * Age of corrections as per last available AGE_CORRECTIONS from PVT engine (0xFFFF indicates - * invalid) - */ + + /** Age of corrections as per last available AGE_CORRECTIONS from PVT + * engine (0xFFFF indicates invalid) */ public int age_corrections; - + /** State of alignment and the status and receipt of the alignment inputs */ public int alignment_status; - + /** Tow of last-used GNSS position measurement */ public long last_used_gnss_pos_tow; - + /** Tow of last-used GNSS velocity measurement */ public long last_used_gnss_vel_tow; - - /** - * Array of Metadata describing the sensors potentially involved in the solution. Each element - * in the array represents a single sensor type and consists of flags containing (meta)data - * pertaining to that specific single sensor. Refer to each (XX)InputType descriptor in the - * present doc. - */ + + /** Array of Metadata describing the sensors potentially involved in the + * solution. Each element in the array represents a single sensor type + * and consists of flags containing (meta)data pertaining to that + * specific single sensor. Refer to each (XX)InputType descriptor in the + * present doc. */ public SolutionInputType[] sol_in; + - public MsgSolnMetaDepA(int sender) { - super(sender, TYPE); - } - - public MsgSolnMetaDepA() { - super(TYPE); - } - - public MsgSolnMetaDepA(SBPMessage msg) throws SBPBinaryException { + public MsgSolnMetaDepA (int sender) { super(sender, TYPE); } + public MsgSolnMetaDepA () { super(TYPE); } + public MsgSolnMetaDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSolnMetaDepA, expected 65295, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSolnMetaDepA, expected 65295, actual " + msg.type); } @Override @@ -100,7 +92,7 @@ protected void parse(Parser parser) throws SBPBinaryException { alignment_status = parser.getU8(); last_used_gnss_pos_tow = parser.getU32(); last_used_gnss_vel_tow = parser.getU32(); - sol_in = parser.getArray(SolutionInputType.class); + sol_in = parser.getArray(SolutionInputType.class); } @Override @@ -113,7 +105,7 @@ protected void build(Builder builder) { builder.putU8(alignment_status); builder.putU32(last_used_gnss_pos_tow); builder.putU32(last_used_gnss_vel_tow); - builder.putArray(sol_in); + builder.putArray(sol_in); } @Override diff --git a/java/src/com/swiftnav/sbp/solution_meta/OdoInputType.java b/java/src/com/swiftnav/sbp/solution_meta/OdoInputType.java index 076416242..e47997784 100644 --- a/java/src/com/swiftnav/sbp/solution_meta/OdoInputType.java +++ b/java/src/com/swiftnav/sbp/solution_meta/OdoInputType.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,23 +9,28 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.solution_meta; // This file was auto-generated from yaml/swiftnav/sbp/solution_meta.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class OdoInputType extends SBPStruct { - + /** Instrument ODO rate, grade, and quality. */ public int flags; + - public OdoInputType() {} + public OdoInputType () {} @Override public OdoInputType parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/solution_meta/SolutionInputType.java b/java/src/com/swiftnav/sbp/solution_meta/SolutionInputType.java index 7a15a9cd6..a16360a7f 100644 --- a/java/src/com/swiftnav/sbp/solution_meta/SolutionInputType.java +++ b/java/src/com/swiftnav/sbp/solution_meta/SolutionInputType.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,26 +9,31 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.solution_meta; // This file was auto-generated from yaml/swiftnav/sbp/solution_meta.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class SolutionInputType extends SBPStruct { - + /** The type of sensor */ public int sensor_type; - + /** Refer to each InputType description */ public int flags; + - public SolutionInputType() {} + public SolutionInputType () {} @Override public SolutionInputType parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/BoundsHeader.java b/java/src/com/swiftnav/sbp/ssr/BoundsHeader.java index 4472f99a1..548694156 100644 --- a/java/src/com/swiftnav/sbp/ssr/BoundsHeader.java +++ b/java/src/com/swiftnav/sbp/ssr/BoundsHeader.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,36 +9,41 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class BoundsHeader extends SBPStruct { - + /** GNSS reference time of the bound */ public GPSTimeSec time; - + /** Number of messages in the dataset */ public int num_msgs; - + /** Position of this message in the dataset */ public int seq_num; - + /** Update interval between consecutive bounds. Similar to RTCM DF391. */ public int update_interval; - + /** SSR Solution ID. */ public int sol_id; + - public BoundsHeader() {} + public BoundsHeader () {} @Override public BoundsHeader parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/CodeBiasesContent.java b/java/src/com/swiftnav/sbp/ssr/CodeBiasesContent.java index 704bfc02a..681cfc896 100644 --- a/java/src/com/swiftnav/sbp/ssr/CodeBiasesContent.java +++ b/java/src/com/swiftnav/sbp/ssr/CodeBiasesContent.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,27 +9,32 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class CodeBiasesContent extends SBPStruct { - + /** Signal encoded following RTCM specifications (DF380, DF381, DF382 and DF467). */ public int code; - + /** Code bias value */ public int value; + - public CodeBiasesContent() {} + public CodeBiasesContent () {} @Override public CodeBiasesContent parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/CodePhaseBiasesSatSig.java b/java/src/com/swiftnav/sbp/ssr/CodePhaseBiasesSatSig.java index 370247f7c..170d2fe9f 100644 --- a/java/src/com/swiftnav/sbp/ssr/CodePhaseBiasesSatSig.java +++ b/java/src/com/swiftnav/sbp/ssr/CodePhaseBiasesSatSig.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,45 +9,46 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class CodePhaseBiasesSatSig extends SBPStruct { - - /** - * Satellite ID. Similar to either RTCM DF068 (GPS), DF252 (Galileo), or DF488 (BDS) depending - * on the constellation. - */ + + /** Satellite ID. Similar to either RTCM DF068 (GPS), DF252 (Galileo), or DF488 + * (BDS) depending on the constellation. */ public int sat_id; - - /** - * Signal and Tracking Mode Identifier. Similar to either RTCM DF380 (GPS), DF382 (Galileo) or - * DF467 (BDS) depending on the constellation. - */ + + /** Signal and Tracking Mode Identifier. Similar to either RTCM DF380 (GPS), DF382 + * (Galileo) or DF467 (BDS) depending on the constellation. */ public int signal_id; - + /** Code Bias Mean. Range: 0-1.275 m */ public int code_bias_bound_mu; - + /** Code Bias Standard Deviation. Range: 0-1.275 m */ public int code_bias_bound_sig; - + /** Phase Bias Mean. Range: 0-1.275 m */ public int phase_bias_bound_mu; - + /** Phase Bias Standard Deviation. Range: 0-1.275 m */ public int phase_bias_bound_sig; + - public CodePhaseBiasesSatSig() {} + public CodePhaseBiasesSatSig () {} @Override public CodePhaseBiasesSatSig parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/GridDefinitionHeaderDepA.java b/java/src/com/swiftnav/sbp/ssr/GridDefinitionHeaderDepA.java index 82d7a32ee..cd4248078 100644 --- a/java/src/com/swiftnav/sbp/ssr/GridDefinitionHeaderDepA.java +++ b/java/src/com/swiftnav/sbp/ssr/GridDefinitionHeaderDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,39 +9,45 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class GridDefinitionHeaderDepA extends SBPStruct { - + /** region_size (deg) = 10 / region_size_inverse 0 is an invalid value. */ public int region_size_inverse; - - /** grid height (deg) = grid width (deg) = area_width / region_size 0 is an invalid value. */ + + /** grid height (deg) = grid width (deg) = area_width / region_size 0 is an invalid + * value. */ public int area_width; - + /** North-West corner latitude (deg) = region_size * lat_nw_corner_enc - 90 */ public int lat_nw_corner_enc; - + /** North-West corner longitude (deg) = region_size * lon_nw_corner_enc - 180 */ public int lon_nw_corner_enc; - + /** Number of messages in the dataset */ public int num_msgs; - + /** Position of this message in the dataset */ public int seq_num; + - public GridDefinitionHeaderDepA() {} + public GridDefinitionHeaderDepA () {} @Override public GridDefinitionHeaderDepA parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/GriddedCorrectionHeader.java b/java/src/com/swiftnav/sbp/ssr/GriddedCorrectionHeader.java index 342e1f64e..ef1b89f6c 100644 --- a/java/src/com/swiftnav/sbp/ssr/GriddedCorrectionHeader.java +++ b/java/src/com/swiftnav/sbp/ssr/GriddedCorrectionHeader.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,49 +9,52 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class GriddedCorrectionHeader extends SBPStruct { - + /** Unique identifier of the tile set this tile belongs to. */ public int tile_set_id; - + /** Unique identifier of this tile in the tile set. */ public int tile_id; - + /** GNSS reference time of the correction */ public GPSTimeSec time; - + /** Number of messages in the dataset */ public int num_msgs; - + /** Position of this message in the dataset */ public int seq_num; - - /** - * Update interval between consecutive corrections. Encoded following RTCM DF391 specification. - */ + + /** Update interval between consecutive corrections. Encoded following RTCM DF391 + * specification. */ public int update_interval; - + /** IOD of the SSR atmospheric correction */ public int iod_atmo; - - /** - * Quality of the troposphere data. Encoded following RTCM DF389 specification in units of m. - */ + + /** Quality of the troposphere data. Encoded following RTCM DF389 specification in + * units of m. */ public int tropo_quality_indicator; + - public GriddedCorrectionHeader() {} + public GriddedCorrectionHeader () {} @Override public GriddedCorrectionHeader parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/GriddedCorrectionHeaderDepA.java b/java/src/com/swiftnav/sbp/ssr/GriddedCorrectionHeaderDepA.java index 12f095f65..87e645f8d 100644 --- a/java/src/com/swiftnav/sbp/ssr/GriddedCorrectionHeaderDepA.java +++ b/java/src/com/swiftnav/sbp/ssr/GriddedCorrectionHeaderDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,43 +9,46 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class GriddedCorrectionHeaderDepA extends SBPStruct { - + /** GNSS reference time of the correction */ public GPSTimeSec time; - + /** Number of messages in the dataset */ public int num_msgs; - + /** Position of this message in the dataset */ public int seq_num; - - /** - * Update interval between consecutive corrections. Encoded following RTCM DF391 specification. - */ + + /** Update interval between consecutive corrections. Encoded following RTCM DF391 + * specification. */ public int update_interval; - + /** IOD of the SSR atmospheric correction */ public int iod_atmo; - - /** - * Quality of the troposphere data. Encoded following RTCM DF389 specification in units of m. - */ + + /** Quality of the troposphere data. Encoded following RTCM DF389 specification in + * units of m. */ public int tropo_quality_indicator; + - public GriddedCorrectionHeaderDepA() {} + public GriddedCorrectionHeaderDepA () {} @Override public GriddedCorrectionHeaderDepA parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrCodeBiases.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrCodeBiases.java index b907d2dda..814c2fde5 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrCodeBiases.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrCodeBiases.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,63 +9,61 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_SSR_CODE_BIASES (0x05E1). + +/** SBP class for message MSG_SSR_CODE_BIASES (0x05E1). * - *

You can have MSG_SSR_CODE_BIASES inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_SSR_CODE_BIASES inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The precise code biases message is to be added to the pseudorange of the corresponding signal - * to get corrected pseudorange. It is an equivalent to the 1059 / 1065 RTCM message types. - */ + * The precise code biases message is to be added to the pseudorange of the + * corresponding signal to get corrected pseudorange. It is an equivalent to + * the 1059 / 1065 RTCM message types. */ + public class MsgSsrCodeBiases extends SBPMessage { public static final int TYPE = 0x05E1; + /** GNSS reference time of the correction */ public GPSTimeSec time; - + /** GNSS signal identifier (16 bit) */ public GnssSignal sid; - - /** - * Update interval between consecutive corrections. Encoded following RTCM DF391 specification. - */ + + /** Update interval between consecutive corrections. Encoded following + * RTCM DF391 specification. */ public int update_interval; - - /** - * IOD of the SSR correction. A change of Issue Of Data SSR is used to indicate a change in the - * SSR generating configuration - */ + + /** IOD of the SSR correction. A change of Issue Of Data SSR is used to + * indicate a change in the SSR generating configuration */ public int iod_ssr; - + /** Code biases for the different satellite signals */ public CodeBiasesContent[] biases; + - public MsgSsrCodeBiases(int sender) { - super(sender, TYPE); - } - - public MsgSsrCodeBiases() { - super(TYPE); - } - - public MsgSsrCodeBiases(SBPMessage msg) throws SBPBinaryException { + public MsgSsrCodeBiases (int sender) { super(sender, TYPE); } + public MsgSsrCodeBiases () { super(TYPE); } + public MsgSsrCodeBiases (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrCodeBiases, expected 1505, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrCodeBiases, expected 1505, actual " + msg.type); } @Override @@ -74,7 +73,7 @@ protected void parse(Parser parser) throws SBPBinaryException { sid = new GnssSignal().parse(parser); update_interval = parser.getU8(); iod_ssr = parser.getU8(); - biases = parser.getArray(CodeBiasesContent.class); + biases = parser.getArray(CodeBiasesContent.class); } @Override @@ -83,7 +82,7 @@ protected void build(Builder builder) { sid.build(builder); builder.putU8(update_interval); builder.putU8(iod_ssr); - builder.putArray(biases); + builder.putArray(biases); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrCodePhaseBiasesBounds.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrCodePhaseBiasesBounds.java index e5c53f394..445802bbf 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrCodePhaseBiasesBounds.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrCodePhaseBiasesBounds.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,50 +9,50 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgSsrCodePhaseBiasesBounds extends SBPMessage { public static final int TYPE = 0x05EC; + /** Header of a bounds message. */ public BoundsHeader header; - + /** IOD of the SSR bound. */ public int ssr_iod; - + /** Constellation ID to which the SVs belong. */ public int const_id; - + /** Number of satellite-signal couples. */ public int n_sats_signals; - + /** Code and Phase Biases Bounds per Satellite-Signal couple. */ public CodePhaseBiasesSatSig[] satellites_signals; + - public MsgSsrCodePhaseBiasesBounds(int sender) { - super(sender, TYPE); - } - - public MsgSsrCodePhaseBiasesBounds() { - super(TYPE); - } - - public MsgSsrCodePhaseBiasesBounds(SBPMessage msg) throws SBPBinaryException { + public MsgSsrCodePhaseBiasesBounds (int sender) { super(sender, TYPE); } + public MsgSsrCodePhaseBiasesBounds () { super(TYPE); } + public MsgSsrCodePhaseBiasesBounds (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrCodePhaseBiasesBounds, expected 1516, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrCodePhaseBiasesBounds, expected 1516, actual " + msg.type); } @Override @@ -61,7 +62,7 @@ protected void parse(Parser parser) throws SBPBinaryException { ssr_iod = parser.getU8(); const_id = parser.getU8(); n_sats_signals = parser.getU8(); - satellites_signals = parser.getArray(CodePhaseBiasesSatSig.class); + satellites_signals = parser.getArray(CodePhaseBiasesSatSig.class); } @Override @@ -70,7 +71,7 @@ protected void build(Builder builder) { builder.putU8(ssr_iod); builder.putU8(const_id); builder.putU8(n_sats_signals); - builder.putArray(satellites_signals); + builder.putArray(satellites_signals); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrGridDefinitionDepA.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrGridDefinitionDepA.java index b6fab0cb1..3b7185406 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrGridDefinitionDepA.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrGridDefinitionDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,66 +9,64 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SSR_GRID_DEFINITION_DEP_A (0x05F5). +/** SBP class for message MSG_SSR_GRID_DEFINITION_DEP_A (0x05F5). * - *

You can have MSG_SSR_GRID_DEFINITION_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_GRID_DEFINITION_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSsrGridDefinitionDepA extends SBPMessage { public static final int TYPE = 0x05F5; + /** Header of a Gridded Correction message */ public GridDefinitionHeaderDepA header; - - /** - * Run Length Encode list of quadrants that contain valid data. The spec describes the encoding - * scheme in detail, but essentially the index of the quadrants that contain transitions between - * valid and invalid (and vice versa) are encoded as u8 integers. - */ + + /** Run Length Encode list of quadrants that contain valid data. The spec + * describes the encoding scheme in detail, but essentially the index of + * the quadrants that contain transitions between valid and invalid (and + * vice versa) are encoded as u8 integers. */ public int[] rle_list; + - public MsgSsrGridDefinitionDepA(int sender) { - super(sender, TYPE); - } - - public MsgSsrGridDefinitionDepA() { - super(TYPE); - } - - public MsgSsrGridDefinitionDepA(SBPMessage msg) throws SBPBinaryException { + public MsgSsrGridDefinitionDepA (int sender) { super(sender, TYPE); } + public MsgSsrGridDefinitionDepA () { super(TYPE); } + public MsgSsrGridDefinitionDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrGridDefinitionDepA, expected 1525, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrGridDefinitionDepA, expected 1525, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ header = new GridDefinitionHeaderDepA().parse(parser); - rle_list = parser.getArrayofU8(); + rle_list = parser.getArrayofU8(); } @Override protected void build(Builder builder) { header.build(builder); - builder.putArrayofU8(rle_list); + builder.putArrayofU8(rle_list); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrection.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrection.java index 3e94a68a4..889b02633 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrection.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrection.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_SSR_GRIDDED_CORRECTION (0x05FC). + +/** SBP class for message MSG_SSR_GRIDDED_CORRECTION (0x05FC). * - *

You can have MSG_SSR_GRIDDED_CORRECTION inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_GRIDDED_CORRECTION inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

STEC residuals are per space vehicle, troposphere is not. + * STEC residuals are per space vehicle, troposphere is not. * - *

It is typically equivalent to the QZSS CLAS Sub Type 9 messages. - */ + * It is typically equivalent to the QZSS CLAS Sub Type 9 messages. */ + public class MsgSsrGriddedCorrection extends SBPMessage { public static final int TYPE = 0x05FC; + /** Header of a gridded correction message */ public GriddedCorrectionHeader header; - + /** Index of the grid point. */ public int index; - + /** Wet and hydrostatic vertical delays (mean, stddev). */ public TroposphericDelayCorrection tropo_delay_correction; - + /** STEC residuals for each satellite (mean, stddev). */ public STECResidual[] stec_residuals; + - public MsgSsrGriddedCorrection(int sender) { - super(sender, TYPE); - } - - public MsgSsrGriddedCorrection() { - super(TYPE); - } - - public MsgSsrGriddedCorrection(SBPMessage msg) throws SBPBinaryException { + public MsgSsrGriddedCorrection (int sender) { super(sender, TYPE); } + public MsgSsrGriddedCorrection () { super(TYPE); } + public MsgSsrGriddedCorrection (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrGriddedCorrection, expected 1532, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrGriddedCorrection, expected 1532, actual " + msg.type); } @Override @@ -66,7 +67,7 @@ protected void parse(Parser parser) throws SBPBinaryException { header = new GriddedCorrectionHeader().parse(parser); index = parser.getU16(); tropo_delay_correction = new TroposphericDelayCorrection().parse(parser); - stec_residuals = parser.getArray(STECResidual.class); + stec_residuals = parser.getArray(STECResidual.class); } @Override @@ -74,7 +75,7 @@ protected void build(Builder builder) { header.build(builder); builder.putU16(index); tropo_delay_correction.build(builder); - builder.putArray(stec_residuals); + builder.putArray(stec_residuals); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionBounds.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionBounds.java index e00b8c375..3a5a493a7 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionBounds.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionBounds.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,83 +9,83 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SSR_GRIDDED_CORRECTION_BOUNDS (0x05FE). +/** SBP class for message MSG_SSR_GRIDDED_CORRECTION_BOUNDS (0x05FE). * - *

You can have MSG_SSR_GRIDDED_CORRECTION_BOUNDS inherent its fields directly from an inherited - * SBP object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_GRIDDED_CORRECTION_BOUNDS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Note 1: Range: 0-17.5 m. i{@literal <}= 200, mean = 0.01i; 200{@literal <}i{@literal <}=230, - * mean=2+0.1(i-200); i{@literal >}230, mean=5+0.5(i-230). - */ + * Note 1: Range: 0-17.5 m. i{@literal <}= 200, mean = 0.01i; 200{@literal <}i{@literal <}=230, + * mean=2+0.1(i-200); i{@literal >}230, mean=5+0.5(i-230). */ + public class MsgSsrGriddedCorrectionBounds extends SBPMessage { public static final int TYPE = 0x05FE; + /** Header of a bounds message. */ public BoundsHeader header; - + /** IOD of the correction. */ public int ssr_iod_atmo; - + /** Set this tile belongs to. */ public int tile_set_id; - + /** Unique identifier of this tile in the tile set. */ public int tile_id; - + /** Tropo Quality Indicator. Similar to RTCM DF389. */ public int tropo_qi; - + /** Index of the Grid Point. */ public int grid_point_id; - + /** Tropospheric delay at grid point. */ public TroposphericDelayCorrection tropo_delay_correction; - + /** Vertical Hydrostatic Error Bound Mean. */ public int tropo_v_hydro_bound_mu; - + /** Vertical Hydrostatic Error Bound StDev. */ public int tropo_v_hydro_bound_sig; - + /** Vertical Wet Error Bound Mean. */ public int tropo_v_wet_bound_mu; - + /** Vertical Wet Error Bound StDev. */ public int tropo_v_wet_bound_sig; - + /** Number of satellites. */ public int n_sats; - - /** Array of STEC polynomial coefficients and its bounds for each space vehicle. */ + + /** Array of STEC polynomial coefficients and its bounds for each space + * vehicle. */ public STECSatElementIntegrity[] stec_sat_list; + - public MsgSsrGriddedCorrectionBounds(int sender) { - super(sender, TYPE); - } - - public MsgSsrGriddedCorrectionBounds() { - super(TYPE); - } - - public MsgSsrGriddedCorrectionBounds(SBPMessage msg) throws SBPBinaryException { + public MsgSsrGriddedCorrectionBounds (int sender) { super(sender, TYPE); } + public MsgSsrGriddedCorrectionBounds () { super(TYPE); } + public MsgSsrGriddedCorrectionBounds (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrGriddedCorrectionBounds, expected 1534, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrGriddedCorrectionBounds, expected 1534, actual " + msg.type); } @Override @@ -102,7 +103,7 @@ protected void parse(Parser parser) throws SBPBinaryException { tropo_v_wet_bound_mu = parser.getU8(); tropo_v_wet_bound_sig = parser.getU8(); n_sats = parser.getU8(); - stec_sat_list = parser.getArray(STECSatElementIntegrity.class); + stec_sat_list = parser.getArray(STECSatElementIntegrity.class); } @Override @@ -119,7 +120,7 @@ protected void build(Builder builder) { builder.putU8(tropo_v_wet_bound_mu); builder.putU8(tropo_v_wet_bound_sig); builder.putU8(n_sats); - builder.putArray(stec_sat_list); + builder.putArray(stec_sat_list); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionDepA.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionDepA.java index 72526f552..965900e92 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionDepA.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,54 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_SSR_GRIDDED_CORRECTION_DEP_A (0x05FA). + +/** SBP class for message MSG_SSR_GRIDDED_CORRECTION_DEP_A (0x05FA). * - *

You can have MSG_SSR_GRIDDED_CORRECTION_DEP_A inherent its fields directly from an inherited - * SBP object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_GRIDDED_CORRECTION_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSsrGriddedCorrectionDepA extends SBPMessage { public static final int TYPE = 0x05FA; + /** Header of a Gridded Correction message */ public GriddedCorrectionHeaderDepA header; - + /** Index of the grid point */ public int index; - + /** Wet and hydrostatic vertical delays (mean, stddev) */ public TroposphericDelayCorrection tropo_delay_correction; - + /** STEC residuals for each satellite (mean, stddev) */ public STECResidual[] stec_residuals; + - public MsgSsrGriddedCorrectionDepA(int sender) { - super(sender, TYPE); - } - - public MsgSsrGriddedCorrectionDepA() { - super(TYPE); - } - - public MsgSsrGriddedCorrectionDepA(SBPMessage msg) throws SBPBinaryException { + public MsgSsrGriddedCorrectionDepA (int sender) { super(sender, TYPE); } + public MsgSsrGriddedCorrectionDepA () { super(TYPE); } + public MsgSsrGriddedCorrectionDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrGriddedCorrectionDepA, expected 1530, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrGriddedCorrectionDepA, expected 1530, actual " + msg.type); } @Override @@ -65,7 +65,7 @@ protected void parse(Parser parser) throws SBPBinaryException { header = new GriddedCorrectionHeaderDepA().parse(parser); index = parser.getU16(); tropo_delay_correction = new TroposphericDelayCorrection().parse(parser); - stec_residuals = parser.getArray(STECResidual.class); + stec_residuals = parser.getArray(STECResidual.class); } @Override @@ -73,7 +73,7 @@ protected void build(Builder builder) { header.build(builder); builder.putU16(index); tropo_delay_correction.build(builder); - builder.putArray(stec_residuals); + builder.putArray(stec_residuals); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionNoStdDepA.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionNoStdDepA.java index 59d8d40b1..ab43a52c8 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionNoStdDepA.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrGriddedCorrectionNoStdDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,54 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A (0x05F0). + +/** SBP class for message MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A (0x05F0). * - *

You can have MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A inherent its fields directly from an - * inherited SBP object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_GRIDDED_CORRECTION_NO_STD_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSsrGriddedCorrectionNoStdDepA extends SBPMessage { public static final int TYPE = 0x05F0; + /** Header of a Gridded Correction message */ public GriddedCorrectionHeaderDepA header; - + /** Index of the grid point */ public int index; - + /** Wet and hydrostatic vertical delays */ public TroposphericDelayCorrectionNoStd tropo_delay_correction; - + /** STEC residuals for each satellite */ public STECResidualNoStd[] stec_residuals; + - public MsgSsrGriddedCorrectionNoStdDepA(int sender) { - super(sender, TYPE); - } - - public MsgSsrGriddedCorrectionNoStdDepA() { - super(TYPE); - } - - public MsgSsrGriddedCorrectionNoStdDepA(SBPMessage msg) throws SBPBinaryException { + public MsgSsrGriddedCorrectionNoStdDepA (int sender) { super(sender, TYPE); } + public MsgSsrGriddedCorrectionNoStdDepA () { super(TYPE); } + public MsgSsrGriddedCorrectionNoStdDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrGriddedCorrectionNoStdDepA, expected 1520, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrGriddedCorrectionNoStdDepA, expected 1520, actual " + msg.type); } @Override @@ -65,7 +65,7 @@ protected void parse(Parser parser) throws SBPBinaryException { header = new GriddedCorrectionHeaderDepA().parse(parser); index = parser.getU16(); tropo_delay_correction = new TroposphericDelayCorrectionNoStd().parse(parser); - stec_residuals = parser.getArray(STECResidualNoStd.class); + stec_residuals = parser.getArray(STECResidualNoStd.class); } @Override @@ -73,7 +73,7 @@ protected void build(Builder builder) { header.build(builder); builder.putU16(index); tropo_delay_correction.build(builder); - builder.putArray(stec_residuals); + builder.putArray(stec_residuals); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClock.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClock.java index 53fc0b71b..0214b521f 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClock.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClock.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,89 +9,88 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SSR_ORBIT_CLOCK (0x05DD). +/** SBP class for message MSG_SSR_ORBIT_CLOCK (0x05DD). * - *

You can have MSG_SSR_ORBIT_CLOCK inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_SSR_ORBIT_CLOCK inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The precise orbit and clock correction message is to be applied as a delta correction to - * broadcast ephemeris and is an equivalent to the 1060 /1066 RTCM message types. - */ + * The precise orbit and clock correction message is to be applied as a delta + * correction to broadcast ephemeris and is an equivalent to the 1060 /1066 + * RTCM message types. */ + public class MsgSsrOrbitClock extends SBPMessage { public static final int TYPE = 0x05DD; + /** GNSS reference time of the correction */ public GPSTimeSec time; - + /** GNSS signal identifier (16 bit) */ public GnssSignal sid; - - /** - * Update interval between consecutive corrections. Encoded following RTCM DF391 specification. - */ + + /** Update interval between consecutive corrections. Encoded following + * RTCM DF391 specification. */ public int update_interval; - - /** - * IOD of the SSR correction. A change of Issue Of Data SSR is used to indicate a change in the - * SSR generating configuration - */ + + /** IOD of the SSR correction. A change of Issue Of Data SSR is used to + * indicate a change in the SSR generating configuration */ public int iod_ssr; - + /** Issue of broadcast ephemeris data or IODCRC (Beidou) */ public long iod; - + /** Orbit radial delta correction */ public int radial; - + /** Orbit along delta correction */ public int along; - + /** Orbit along delta correction */ public int cross; - + /** Velocity of orbit radial delta correction */ public int dot_radial; - + /** Velocity of orbit along delta correction */ public int dot_along; - + /** Velocity of orbit cross delta correction */ public int dot_cross; - + /** C0 polynomial coefficient for correction of broadcast satellite clock */ public int c0; - + /** C1 polynomial coefficient for correction of broadcast satellite clock */ public int c1; - + /** C2 polynomial coefficient for correction of broadcast satellite clock */ public int c2; + - public MsgSsrOrbitClock(int sender) { - super(sender, TYPE); - } - - public MsgSsrOrbitClock() { - super(TYPE); - } - - public MsgSsrOrbitClock(SBPMessage msg) throws SBPBinaryException { + public MsgSsrOrbitClock (int sender) { super(sender, TYPE); } + public MsgSsrOrbitClock () { super(TYPE); } + public MsgSsrOrbitClock (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrOrbitClock, expected 1501, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrOrbitClock, expected 1501, actual " + msg.type); } @Override @@ -109,7 +109,7 @@ protected void parse(Parser parser) throws SBPBinaryException { dot_cross = parser.getS32(); c0 = parser.getS32(); c1 = parser.getS32(); - c2 = parser.getS32(); + c2 = parser.getS32(); } @Override @@ -127,7 +127,7 @@ protected void build(Builder builder) { builder.putS32(dot_cross); builder.putS32(c0); builder.putS32(c1); - builder.putS32(c2); + builder.putS32(c2); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBounds.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBounds.java index a6404815e..0f3df0d4f 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBounds.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBounds.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,61 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_SSR_ORBIT_CLOCK_BOUNDS (0x05DE). + +/** SBP class for message MSG_SSR_ORBIT_CLOCK_BOUNDS (0x05DE). * - *

You can have MSG_SSR_ORBIT_CLOCK_BOUNDS inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_ORBIT_CLOCK_BOUNDS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Note 1: Range: 0-17.5 m. i{@literal <}=200, mean=0.01i; 200{@literal <}i{@literal <}=230, - * mean=2+0.1(i-200); i{@literal >}230, mean=5+0.5(i-230). + * Note 1: Range: 0-17.5 m. i{@literal <}=200, mean=0.01i; 200{@literal <}i{@literal <}=230, mean=2+0.1(i-200); + * i{@literal >}230, mean=5+0.5(i-230). * - *

Note 2: Range: 0-17.5 m. i{@literal <}=200, std=0.01i; 200{@literal <}i{@literal <}=230, - * std=2+0.1(i-200) i{@literal >}230, std=5+0.5(i-230). - */ + * Note 2: Range: 0-17.5 m. i{@literal <}=200, std=0.01i; 200{@literal <}i{@literal <}=230, std=2+0.1(i-200) + * i{@literal >}230, std=5+0.5(i-230). */ + public class MsgSsrOrbitClockBounds extends SBPMessage { public static final int TYPE = 0x05DE; + /** Header of a bounds message. */ public BoundsHeader header; - + /** IOD of the SSR bound. */ public int ssr_iod; - + /** Constellation ID to which the SVs belong. */ public int const_id; - + /** Number of satellites. */ public int n_sats; - + /** Orbit and Clock Bounds per Satellite */ public OrbitClockBound[] orbit_clock_bounds; + - public MsgSsrOrbitClockBounds(int sender) { - super(sender, TYPE); - } - - public MsgSsrOrbitClockBounds() { - super(TYPE); - } - - public MsgSsrOrbitClockBounds(SBPMessage msg) throws SBPBinaryException { + public MsgSsrOrbitClockBounds (int sender) { super(sender, TYPE); } + public MsgSsrOrbitClockBounds () { super(TYPE); } + public MsgSsrOrbitClockBounds (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrOrbitClockBounds, expected 1502, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrOrbitClockBounds, expected 1502, actual " + msg.type); } @Override @@ -72,7 +73,7 @@ protected void parse(Parser parser) throws SBPBinaryException { ssr_iod = parser.getU8(); const_id = parser.getU8(); n_sats = parser.getU8(); - orbit_clock_bounds = parser.getArray(OrbitClockBound.class); + orbit_clock_bounds = parser.getArray(OrbitClockBound.class); } @Override @@ -81,7 +82,7 @@ protected void build(Builder builder) { builder.putU8(ssr_iod); builder.putU8(const_id); builder.putU8(n_sats); - builder.putArray(orbit_clock_bounds); + builder.putArray(orbit_clock_bounds); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBoundsDegradation.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBoundsDegradation.java index 6537e5576..6c5453c3c 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBoundsDegradation.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockBoundsDegradation.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,53 +9,52 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import java.math.BigInteger; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgSsrOrbitClockBoundsDegradation extends SBPMessage { public static final int TYPE = 0x05DF; + /** Header of a bounds message. */ public BoundsHeader header; - + /** IOD of the SSR bound degradation parameter. */ public int ssr_iod; - + /** Constellation ID to which the SVs belong. */ public int const_id; - - /** - * Satellite Bit Mask. Put 1 for each satellite where the following degradation parameters are - * applicable, 0 otherwise. Encoded following RTCM DF394 specification. - */ + + /** Satellite Bit Mask. Put 1 for each satellite where the following + * degradation parameters are applicable, 0 otherwise. Encoded following + * RTCM DF394 specification. */ public BigInteger sat_bitmask; - + /** Orbit and Clock Bounds Degradation Parameters */ public OrbitClockBoundDegradation orbit_clock_bounds_degradation; + - public MsgSsrOrbitClockBoundsDegradation(int sender) { - super(sender, TYPE); - } - - public MsgSsrOrbitClockBoundsDegradation() { - super(TYPE); - } - - public MsgSsrOrbitClockBoundsDegradation(SBPMessage msg) throws SBPBinaryException { + public MsgSsrOrbitClockBoundsDegradation (int sender) { super(sender, TYPE); } + public MsgSsrOrbitClockBoundsDegradation () { super(TYPE); } + public MsgSsrOrbitClockBoundsDegradation (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrOrbitClockBoundsDegradation, expected 1503, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrOrbitClockBoundsDegradation, expected 1503, actual " + msg.type); } @Override @@ -64,7 +64,7 @@ protected void parse(Parser parser) throws SBPBinaryException { ssr_iod = parser.getU8(); const_id = parser.getU8(); sat_bitmask = parser.getU64(); - orbit_clock_bounds_degradation = new OrbitClockBoundDegradation().parse(parser); + orbit_clock_bounds_degradation = new OrbitClockBoundDegradation().parse(parser); } @Override @@ -73,7 +73,7 @@ protected void build(Builder builder) { builder.putU8(ssr_iod); builder.putU8(const_id); builder.putU64(sat_bitmask); - orbit_clock_bounds_degradation.build(builder); + orbit_clock_bounds_degradation.build(builder); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockDepA.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockDepA.java index 6d5aa6837..432348be1 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockDepA.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrOrbitClockDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,88 +9,86 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SSR_ORBIT_CLOCK_DEP_A (0x05DC). +/** SBP class for message MSG_SSR_ORBIT_CLOCK_DEP_A (0x05DC). * - *

You can have MSG_SSR_ORBIT_CLOCK_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_ORBIT_CLOCK_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSsrOrbitClockDepA extends SBPMessage { public static final int TYPE = 0x05DC; + /** GNSS reference time of the correction */ public GPSTimeSec time; - + /** GNSS signal identifier (16 bit) */ public GnssSignal sid; - - /** - * Update interval between consecutive corrections. Encoded following RTCM DF391 specification. - */ + + /** Update interval between consecutive corrections. Encoded following + * RTCM DF391 specification. */ public int update_interval; - - /** - * IOD of the SSR correction. A change of Issue Of Data SSR is used to indicate a change in the - * SSR generating configuration - */ + + /** IOD of the SSR correction. A change of Issue Of Data SSR is used to + * indicate a change in the SSR generating configuration */ public int iod_ssr; - + /** Issue of broadcast ephemeris data */ public int iod; - + /** Orbit radial delta correction */ public int radial; - + /** Orbit along delta correction */ public int along; - + /** Orbit along delta correction */ public int cross; - + /** Velocity of orbit radial delta correction */ public int dot_radial; - + /** Velocity of orbit along delta correction */ public int dot_along; - + /** Velocity of orbit cross delta correction */ public int dot_cross; - + /** C0 polynomial coefficient for correction of broadcast satellite clock */ public int c0; - + /** C1 polynomial coefficient for correction of broadcast satellite clock */ public int c1; - + /** C2 polynomial coefficient for correction of broadcast satellite clock */ public int c2; + - public MsgSsrOrbitClockDepA(int sender) { - super(sender, TYPE); - } - - public MsgSsrOrbitClockDepA() { - super(TYPE); - } - - public MsgSsrOrbitClockDepA(SBPMessage msg) throws SBPBinaryException { + public MsgSsrOrbitClockDepA (int sender) { super(sender, TYPE); } + public MsgSsrOrbitClockDepA () { super(TYPE); } + public MsgSsrOrbitClockDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrOrbitClockDepA, expected 1500, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrOrbitClockDepA, expected 1500, actual " + msg.type); } @Override @@ -108,7 +107,7 @@ protected void parse(Parser parser) throws SBPBinaryException { dot_cross = parser.getS32(); c0 = parser.getS32(); c1 = parser.getS32(); - c2 = parser.getS32(); + c2 = parser.getS32(); } @Override @@ -126,7 +125,7 @@ protected void build(Builder builder) { builder.putS32(dot_cross); builder.putS32(c0); builder.putS32(c1); - builder.putS32(c2); + builder.putS32(c2); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrPhaseBiases.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrPhaseBiases.java index 918fe0cda..c54472d34 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrPhaseBiases.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrPhaseBiases.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,77 +9,75 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SSR_PHASE_BIASES (0x05E6). +/** SBP class for message MSG_SSR_PHASE_BIASES (0x05E6). * - *

You can have MSG_SSR_PHASE_BIASES inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_SSR_PHASE_BIASES inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The precise phase biases message contains the biases to be added to the carrier phase of the - * corresponding signal to get corrected carrier phase measurement, as well as the satellite yaw - * angle to be applied to compute the phase wind-up correction. It is typically an equivalent to the - * 1265 RTCM message types. - */ + * The precise phase biases message contains the biases to be added to the + * carrier phase of the corresponding signal to get corrected carrier phase + * measurement, as well as the satellite yaw angle to be applied to compute + * the phase wind-up correction. It is typically an equivalent to the 1265 + * RTCM message types. */ + public class MsgSsrPhaseBiases extends SBPMessage { public static final int TYPE = 0x05E6; + /** GNSS reference time of the correction */ public GPSTimeSec time; - + /** GNSS signal identifier (16 bit) */ public GnssSignal sid; - - /** - * Update interval between consecutive corrections. Encoded following RTCM DF391 specification. - */ + + /** Update interval between consecutive corrections. Encoded following + * RTCM DF391 specification. */ public int update_interval; - - /** - * IOD of the SSR correction. A change of Issue Of Data SSR is used to indicate a change in the - * SSR generating configuration - */ + + /** IOD of the SSR correction. A change of Issue Of Data SSR is used to + * indicate a change in the SSR generating configuration */ public int iod_ssr; - + /** Indicator for the dispersive phase biases property. */ public int dispersive_bias; - + /** Consistency indicator for Melbourne-Wubbena linear combinations */ public int mw_consistency; - + /** Satellite yaw angle */ public int yaw; - + /** Satellite yaw angle rate */ public int yaw_rate; - + /** Phase biases corrections for a satellite being tracked. */ public PhaseBiasesContent[] biases; + - public MsgSsrPhaseBiases(int sender) { - super(sender, TYPE); - } - - public MsgSsrPhaseBiases() { - super(TYPE); - } - - public MsgSsrPhaseBiases(SBPMessage msg) throws SBPBinaryException { + public MsgSsrPhaseBiases (int sender) { super(sender, TYPE); } + public MsgSsrPhaseBiases () { super(TYPE); } + public MsgSsrPhaseBiases (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrPhaseBiases, expected 1510, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrPhaseBiases, expected 1510, actual " + msg.type); } @Override @@ -92,7 +91,7 @@ protected void parse(Parser parser) throws SBPBinaryException { mw_consistency = parser.getU8(); yaw = parser.getU16(); yaw_rate = parser.getS8(); - biases = parser.getArray(PhaseBiasesContent.class); + biases = parser.getArray(PhaseBiasesContent.class); } @Override @@ -105,7 +104,7 @@ protected void build(Builder builder) { builder.putU8(mw_consistency); builder.putU16(yaw); builder.putS8(yaw_rate); - builder.putArray(biases); + builder.putArray(biases); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrSatelliteApc.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrSatelliteApc.java index 1ba8fa943..22672dfa1 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrSatelliteApc.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrSatelliteApc.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,54 +9,52 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgSsrSatelliteApc extends SBPMessage { public static final int TYPE = 0x0605; + /** GNSS reference time of the correction */ public GPSTimeSec time; - - /** - * Update interval between consecutive corrections. Encoded following RTCM DF391 specification. - */ + + /** Update interval between consecutive corrections. Encoded following + * RTCM DF391 specification. */ public int update_interval; - + /** SSR Solution ID. Similar to RTCM DF415. */ public int sol_id; - - /** - * IOD of the SSR correction. A change of Issue Of Data SSR is used to indicate a change in the - * SSR generating configuration - */ + + /** IOD of the SSR correction. A change of Issue Of Data SSR is used to + * indicate a change in the SSR generating configuration */ public int iod_ssr; - + /** Satellite antenna phase center corrections */ public SatelliteAPC[] apc; + - public MsgSsrSatelliteApc(int sender) { - super(sender, TYPE); - } - - public MsgSsrSatelliteApc() { - super(TYPE); - } - - public MsgSsrSatelliteApc(SBPMessage msg) throws SBPBinaryException { + public MsgSsrSatelliteApc (int sender) { super(sender, TYPE); } + public MsgSsrSatelliteApc () { super(TYPE); } + public MsgSsrSatelliteApc (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrSatelliteApc, expected 1541, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrSatelliteApc, expected 1541, actual " + msg.type); } @Override @@ -65,7 +64,7 @@ protected void parse(Parser parser) throws SBPBinaryException { update_interval = parser.getU8(); sol_id = parser.getU8(); iod_ssr = parser.getU8(); - apc = parser.getArray(SatelliteAPC.class); + apc = parser.getArray(SatelliteAPC.class); } @Override @@ -74,7 +73,7 @@ protected void build(Builder builder) { builder.putU8(update_interval); builder.putU8(sol_id); builder.putU8(iod_ssr); - builder.putArray(apc); + builder.putArray(apc); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrSatelliteApcDep.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrSatelliteApcDep.java index 2a4a5cbda..cbc2397ee 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrSatelliteApcDep.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrSatelliteApcDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SSR_SATELLITE_APC_DEP (0x0604). +/** SBP class for message MSG_SSR_SATELLITE_APC_DEP (0x0604). * - *

You can have MSG_SSR_SATELLITE_APC_DEP inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_SATELLITE_APC_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSsrSatelliteApcDep extends SBPMessage { public static final int TYPE = 0x0604; + /** Satellite antenna phase center corrections */ public SatelliteAPC[] apc; + - public MsgSsrSatelliteApcDep(int sender) { - super(sender, TYPE); - } - - public MsgSsrSatelliteApcDep() { - super(TYPE); - } - - public MsgSsrSatelliteApcDep(SBPMessage msg) throws SBPBinaryException { + public MsgSsrSatelliteApcDep (int sender) { super(sender, TYPE); } + public MsgSsrSatelliteApcDep () { super(TYPE); } + public MsgSsrSatelliteApcDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrSatelliteApcDep, expected 1540, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrSatelliteApcDep, expected 1540, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - apc = parser.getArray(SatelliteAPC.class); + apc = parser.getArray(SatelliteAPC.class); } @Override protected void build(Builder builder) { - builder.putArray(apc); + builder.putArray(apc); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrection.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrection.java index f82cf3e79..0bcebd06d 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrection.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrection.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,52 +9,53 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + + public class MsgSsrStecCorrection extends SBPMessage { public static final int TYPE = 0x05FD; + /** Header of a STEC correction with bounds message. */ public BoundsHeader header; - + /** IOD of the SSR atmospheric correction */ public int ssr_iod_atmo; - + /** Tile set ID */ public int tile_set_id; - + /** Tile ID */ public int tile_id; - + /** Number of satellites. */ public int n_sats; - + /** Array of STEC polynomial coefficients for each space vehicle. */ public STECSatElement[] stec_sat_list; + - public MsgSsrStecCorrection(int sender) { - super(sender, TYPE); - } - - public MsgSsrStecCorrection() { - super(TYPE); - } - - public MsgSsrStecCorrection(SBPMessage msg) throws SBPBinaryException { + public MsgSsrStecCorrection (int sender) { super(sender, TYPE); } + public MsgSsrStecCorrection () { super(TYPE); } + public MsgSsrStecCorrection (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrStecCorrection, expected 1533, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrStecCorrection, expected 1533, actual " + msg.type); } @Override @@ -64,7 +66,7 @@ protected void parse(Parser parser) throws SBPBinaryException { tile_set_id = parser.getU16(); tile_id = parser.getU16(); n_sats = parser.getU8(); - stec_sat_list = parser.getArray(STECSatElement.class); + stec_sat_list = parser.getArray(STECSatElement.class); } @Override @@ -74,7 +76,7 @@ protected void build(Builder builder) { builder.putU16(tile_set_id); builder.putU16(tile_id); builder.putU8(n_sats); - builder.putArray(stec_sat_list); + builder.putArray(stec_sat_list); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrectionDep.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrectionDep.java index 438510495..722c0e35e 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrectionDep.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrectionDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,61 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SSR_STEC_CORRECTION_DEP (0x05FB). +/** SBP class for message MSG_SSR_STEC_CORRECTION_DEP (0x05FB). * - *

You can have MSG_SSR_STEC_CORRECTION_DEP inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_STEC_CORRECTION_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSsrStecCorrectionDep extends SBPMessage { public static final int TYPE = 0x05FB; + /** Header of a STEC polynomial coefficient message. */ public STECHeader header; - + /** Array of STEC polynomial coefficients for each space vehicle. */ public STECSatElement[] stec_sat_list; + - public MsgSsrStecCorrectionDep(int sender) { - super(sender, TYPE); - } - - public MsgSsrStecCorrectionDep() { - super(TYPE); - } - - public MsgSsrStecCorrectionDep(SBPMessage msg) throws SBPBinaryException { + public MsgSsrStecCorrectionDep (int sender) { super(sender, TYPE); } + public MsgSsrStecCorrectionDep () { super(TYPE); } + public MsgSsrStecCorrectionDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrStecCorrectionDep, expected 1531, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrStecCorrectionDep, expected 1531, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ header = new STECHeader().parse(parser); - stec_sat_list = parser.getArray(STECSatElement.class); + stec_sat_list = parser.getArray(STECSatElement.class); } @Override protected void build(Builder builder) { header.build(builder); - builder.putArray(stec_sat_list); + builder.putArray(stec_sat_list); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrectionDepA.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrectionDepA.java index ebd11765b..d7a333167 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrectionDepA.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrStecCorrectionDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,62 +9,61 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SSR_STEC_CORRECTION_DEP_A (0x05EB). +/** SBP class for message MSG_SSR_STEC_CORRECTION_DEP_A (0x05EB). * - *

You can have MSG_SSR_STEC_CORRECTION_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_STEC_CORRECTION_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSsrStecCorrectionDepA extends SBPMessage { public static final int TYPE = 0x05EB; + /** Header of a STEC message */ public STECHeaderDepA header; - + /** Array of STEC information for each space vehicle */ public STECSatElement[] stec_sat_list; + - public MsgSsrStecCorrectionDepA(int sender) { - super(sender, TYPE); - } - - public MsgSsrStecCorrectionDepA() { - super(TYPE); - } - - public MsgSsrStecCorrectionDepA(SBPMessage msg) throws SBPBinaryException { + public MsgSsrStecCorrectionDepA (int sender) { super(sender, TYPE); } + public MsgSsrStecCorrectionDepA () { super(TYPE); } + public MsgSsrStecCorrectionDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrStecCorrectionDepA, expected 1515, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrStecCorrectionDepA, expected 1515, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ header = new STECHeaderDepA().parse(parser); - stec_sat_list = parser.getArray(STECSatElement.class); + stec_sat_list = parser.getArray(STECSatElement.class); } @Override protected void build(Builder builder) { header.build(builder); - builder.putArray(stec_sat_list); + builder.putArray(stec_sat_list); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinition.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinition.java index 146dab766..4500ac7fd 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinition.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinition.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,134 +9,120 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import java.math.BigInteger; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SSR_TILE_DEFINITION (0x05F8). +/** SBP class for message MSG_SSR_TILE_DEFINITION (0x05F8). * - *

You can have MSG_SSR_TILE_DEFINITION inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_TILE_DEFINITION inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Provides the correction point coordinates for the atmospheric correction values in the - * MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION messages. + * Provides the correction point coordinates for the atmospheric correction + * values in the MSG_SSR_STEC_CORRECTION and MSG_SSR_GRIDDED_CORRECTION + * messages. * - *

Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information element - * GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of correction points, not lists of - * points. - */ + * Based on ETSI TS 137 355 V16.1.0 (LTE Positioning Protocol) information + * element GNSS-SSR-CorrectionPoints. SBP only supports gridded arrays of + * correction points, not lists of points. */ + public class MsgSsrTileDefinition extends SBPMessage { public static final int TYPE = 0x05F8; + /** GNSS reference time of the correction */ public GPSTimeSec time; - - /** - * Update interval between consecutive corrections. Encoded following RTCM DF391 specification. - */ + + /** Update interval between consecutive corrections. Encoded following + * RTCM DF391 specification. */ public int update_interval; - + /** SSR Solution ID. Similar to RTCM DF415. */ public int sol_id; - + /** IOD of the SSR atmospheric correction. */ public int iod_atmo; - + /** Unique identifier of the tile set this tile belongs to. */ public int tile_set_id; - - /** - * Unique identifier of this tile in the tile set. See GNSS-SSR-ArrayOfCorrectionPoints field - * correctionPointSetID. - */ + + /** Unique identifier of this tile in the tile set. + * See GNSS-SSR-ArrayOfCorrectionPoints field correctionPointSetID. */ public int tile_id; - - /** - * North-West corner correction point latitude. - * - *

The relation between the latitude X in the range [-90, 90] and the coded number N is: N = - * floor((X / 90) * 2^14) - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLatitude. - */ + + /** North-West corner correction point latitude. + * + * The relation between the latitude X in the range [-90, 90] and the + * coded number N is: N = floor((X / 90) * 2^14) + * + * See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLatitude. */ public int corner_nw_lat; - - /** - * North-West corner correction point longitude. - * - *

The relation between the longitude X in the range [-180, 180] and the coded number N is: N - * = floor((X / 180) * 2^15) - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLongitude. - */ + + /** North-West corner correction point longitude. + * + * The relation between the longitude X in the range [-180, 180] and the + * coded number N is: N = floor((X / 180) * 2^15) + * + * See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLongitude. */ public int corner_nw_lon; - - /** - * Spacing of the correction points in the latitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLatitude. - */ + + /** Spacing of the correction points in the latitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLatitude. */ public int spacing_lat; - - /** - * Spacing of the correction points in the longitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLongitude. - */ + + /** Spacing of the correction points in the longitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLongitude. */ public int spacing_lon; - - /** - * Number of steps in the latitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLatitude. - */ + + /** Number of steps in the latitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLatitude. */ public int rows; - - /** - * Number of steps in the longitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLongitude. - */ + + /** Number of steps in the longitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLongitude. */ public int cols; - - /** - * Specifies the absence of correction data at the correction points in the array (grid). - * - *

Only the first rows * cols bits are used, and if a specific bit is enabled (set to 1), the - * correction is not available. If there are more than 64 correction points the remaining - * corrections are always available. - * - *

The correction points are packed by rows, starting with the northwest corner of the array - * (top-left on a north oriented map), with each row spanning west to east, ending with the - * southeast corner of the array. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field bitmaskOfGrids but note the definition of the - * bits is inverted. - */ + + /** Specifies the absence of correction data at the correction points in + * the array (grid). + * + * Only the first rows * cols bits are used, and if a specific bit is + * enabled (set to 1), the correction is not available. If there are more + * than 64 correction points the remaining corrections are always + * available. + * + * The correction points are packed by rows, starting with the northwest + * corner of the array (top-left on a north oriented map), with each row + * spanning west to east, ending with the southeast corner of the array. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field bitmaskOfGrids but note the + * definition of the bits is inverted. */ public BigInteger bitmask; + - public MsgSsrTileDefinition(int sender) { - super(sender, TYPE); - } - - public MsgSsrTileDefinition() { - super(TYPE); - } - - public MsgSsrTileDefinition(SBPMessage msg) throws SBPBinaryException { + public MsgSsrTileDefinition (int sender) { super(sender, TYPE); } + public MsgSsrTileDefinition () { super(TYPE); } + public MsgSsrTileDefinition (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrTileDefinition, expected 1528, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrTileDefinition, expected 1528, actual " + msg.type); } @Override @@ -153,7 +140,7 @@ protected void parse(Parser parser) throws SBPBinaryException { spacing_lon = parser.getU16(); rows = parser.getU16(); cols = parser.getU16(); - bitmask = parser.getU64(); + bitmask = parser.getU64(); } @Override @@ -170,7 +157,7 @@ protected void build(Builder builder) { builder.putU16(spacing_lon); builder.putU16(rows); builder.putU16(cols); - builder.putU64(bitmask); + builder.putU64(bitmask); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinitionDepA.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinitionDepA.java index b8233a3ba..d0bb31a25 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinitionDepA.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinitionDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,118 +9,106 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import java.math.BigInteger; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_SSR_TILE_DEFINITION_DEP_A (0x05F6). + +/** SBP class for message MSG_SSR_TILE_DEFINITION_DEP_A (0x05F6). * - *

You can have MSG_SSR_TILE_DEFINITION_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_TILE_DEFINITION_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSsrTileDefinitionDepA extends SBPMessage { public static final int TYPE = 0x05F6; + /** Unique identifier of the tile set this tile belongs to. */ public int tile_set_id; - - /** - * Unique identifier of this tile in the tile set. See GNSS-SSR-ArrayOfCorrectionPoints field - * correctionPointSetID. - */ + + /** Unique identifier of this tile in the tile set. + * See GNSS-SSR-ArrayOfCorrectionPoints field correctionPointSetID. */ public int tile_id; - - /** - * North-West corner correction point latitude. - * - *

The relation between the latitude X in the range [-90, 90] and the coded number N is: - * - *

N = floor((X / 90) * 2^14) - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLatitude. - */ + + /** North-West corner correction point latitude. + * + * The relation between the latitude X in the range [-90, 90] and the + * coded number N is: + * + * N = floor((X / 90) * 2^14) + * + * See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLatitude. */ public int corner_nw_lat; - - /** - * North-West corner correction point longitude. - * - *

The relation between the longitude X in the range [-180, 180] and the coded number N is: - * - *

N = floor((X / 180) * 2^15) - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLongitude. - */ + + /** North-West corner correction point longitude. + * + * The relation between the longitude X in the range [-180, 180] and the + * coded number N is: + * + * N = floor((X / 180) * 2^15) + * + * See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLongitude. */ public int corner_nw_lon; - - /** - * Spacing of the correction points in the latitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLatitude. - */ + + /** Spacing of the correction points in the latitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLatitude. */ public int spacing_lat; - - /** - * Spacing of the correction points in the longitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLongitude. - */ + + /** Spacing of the correction points in the longitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLongitude. */ public int spacing_lon; - - /** - * Number of steps in the latitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLatitude. - */ + + /** Number of steps in the latitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLatitude. */ public int rows; - - /** - * Number of steps in the longitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLongitude. - */ + + /** Number of steps in the longitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLongitude. */ public int cols; - - /** - * Specifies the availability of correction data at the correction points in the array. - * - *

If a specific bit is enabled (set to 1), the correction is not available. Only the first - * rows * cols bits are used, the remainder are set to 0. If there are more then 64 correction - * points the remaining corrections are always available. - * - *

Starting with the northwest corner of the array (top left on a north oriented map) the - * correction points are enumerated with row precedence - first row west to east, second row - * west to east, until last row west to east - ending with the southeast corner of the array. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field bitmaskOfGrids but note the definition of the - * bits is inverted. - */ + + /** Specifies the availability of correction data at the correction points + * in the array. + * + * If a specific bit is enabled (set to 1), the correction is not + * available. Only the first rows * cols bits are used, the remainder are + * set to 0. If there are more then 64 correction points the remaining + * corrections are always available. + * + * Starting with the northwest corner of the array (top left on a north + * oriented map) the correction points are enumerated with row precedence + * - first row west to east, second row west to east, until last row west + * to east - ending with the southeast corner of the array. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field bitmaskOfGrids but note the + * definition of the bits is inverted. */ public BigInteger bitmask; + - public MsgSsrTileDefinitionDepA(int sender) { - super(sender, TYPE); - } - - public MsgSsrTileDefinitionDepA() { - super(TYPE); - } - - public MsgSsrTileDefinitionDepA(SBPMessage msg) throws SBPBinaryException { + public MsgSsrTileDefinitionDepA (int sender) { super(sender, TYPE); } + public MsgSsrTileDefinitionDepA () { super(TYPE); } + public MsgSsrTileDefinitionDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrTileDefinitionDepA, expected 1526, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrTileDefinitionDepA, expected 1526, actual " + msg.type); } @Override @@ -133,7 +122,7 @@ protected void parse(Parser parser) throws SBPBinaryException { spacing_lon = parser.getU16(); rows = parser.getU16(); cols = parser.getU16(); - bitmask = parser.getU64(); + bitmask = parser.getU64(); } @Override @@ -146,7 +135,7 @@ protected void build(Builder builder) { builder.putU16(spacing_lon); builder.putU16(rows); builder.putU16(cols); - builder.putU64(bitmask); + builder.putU64(bitmask); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinitionDepB.java b/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinitionDepB.java index 28770d999..9ce0d93ca 100644 --- a/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinitionDepB.java +++ b/java/src/com/swiftnav/sbp/ssr/MsgSsrTileDefinitionDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,121 +9,109 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import java.math.BigInteger; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_SSR_TILE_DEFINITION_DEP_B (0x05F7). + +/** SBP class for message MSG_SSR_TILE_DEFINITION_DEP_B (0x05F7). * - *

You can have MSG_SSR_TILE_DEFINITION_DEP_B inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_SSR_TILE_DEFINITION_DEP_B inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgSsrTileDefinitionDepB extends SBPMessage { public static final int TYPE = 0x05F7; + /** SSR Solution ID. */ public int ssr_sol_id; - + /** Unique identifier of the tile set this tile belongs to. */ public int tile_set_id; - - /** - * Unique identifier of this tile in the tile set. See GNSS-SSR-ArrayOfCorrectionPoints field - * correctionPointSetID. - */ + + /** Unique identifier of this tile in the tile set. + * See GNSS-SSR-ArrayOfCorrectionPoints field correctionPointSetID. */ public int tile_id; - - /** - * North-West corner correction point latitude. - * - *

The relation between the latitude X in the range [-90, 90] and the coded number N is: - * - *

N = floor((X / 90) * 2^14) - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLatitude. - */ + + /** North-West corner correction point latitude. + * + * The relation between the latitude X in the range [-90, 90] and the + * coded number N is: + * + * N = floor((X / 90) * 2^14) + * + * See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLatitude. */ public int corner_nw_lat; - - /** - * North-West corner correction point longitude. - * - *

The relation between the longitude X in the range [-180, 180] and the coded number N is: - * - *

N = floor((X / 180) * 2^15) - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLongitude. - */ + + /** North-West corner correction point longitude. + * + * The relation between the longitude X in the range [-180, 180] and the + * coded number N is: + * + * N = floor((X / 180) * 2^15) + * + * See GNSS-SSR-ArrayOfCorrectionPoints field referencePointLongitude. */ public int corner_nw_lon; - - /** - * Spacing of the correction points in the latitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLatitude. - */ + + /** Spacing of the correction points in the latitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLatitude. */ public int spacing_lat; - - /** - * Spacing of the correction points in the longitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLongitude. - */ + + /** Spacing of the correction points in the longitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field stepOfLongitude. */ public int spacing_lon; - - /** - * Number of steps in the latitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLatitude. - */ + + /** Number of steps in the latitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLatitude. */ public int rows; - - /** - * Number of steps in the longitude direction. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLongitude. - */ + + /** Number of steps in the longitude direction. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field numberOfStepsLongitude. */ public int cols; - - /** - * Specifies the availability of correction data at the correction points in the array. - * - *

If a specific bit is enabled (set to 1), the correction is not available. Only the first - * rows * cols bits are used, the remainder are set to 0. If there are more then 64 correction - * points the remaining corrections are always available. - * - *

Starting with the northwest corner of the array (top left on a north oriented map) the - * correction points are enumerated with row precedence - first row west to east, second row - * west to east, until last row west to east - ending with the southeast corner of the array. - * - *

See GNSS-SSR-ArrayOfCorrectionPoints field bitmaskOfGrids but note the definition of the - * bits is inverted. - */ + + /** Specifies the availability of correction data at the correction points + * in the array. + * + * If a specific bit is enabled (set to 1), the correction is not + * available. Only the first rows * cols bits are used, the remainder are + * set to 0. If there are more then 64 correction points the remaining + * corrections are always available. + * + * Starting with the northwest corner of the array (top left on a north + * oriented map) the correction points are enumerated with row precedence + * - first row west to east, second row west to east, until last row west + * to east - ending with the southeast corner of the array. + * + * See GNSS-SSR-ArrayOfCorrectionPoints field bitmaskOfGrids but note the + * definition of the bits is inverted. */ public BigInteger bitmask; + - public MsgSsrTileDefinitionDepB(int sender) { - super(sender, TYPE); - } - - public MsgSsrTileDefinitionDepB() { - super(TYPE); - } - - public MsgSsrTileDefinitionDepB(SBPMessage msg) throws SBPBinaryException { + public MsgSsrTileDefinitionDepB (int sender) { super(sender, TYPE); } + public MsgSsrTileDefinitionDepB () { super(TYPE); } + public MsgSsrTileDefinitionDepB (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSsrTileDefinitionDepB, expected 1527, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSsrTileDefinitionDepB, expected 1527, actual " + msg.type); } @Override @@ -137,7 +126,7 @@ protected void parse(Parser parser) throws SBPBinaryException { spacing_lon = parser.getU16(); rows = parser.getU16(); cols = parser.getU16(); - bitmask = parser.getU64(); + bitmask = parser.getU64(); } @Override @@ -151,7 +140,7 @@ protected void build(Builder builder) { builder.putU16(spacing_lon); builder.putU16(rows); builder.putU16(cols); - builder.putU64(bitmask); + builder.putU64(bitmask); } @Override diff --git a/java/src/com/swiftnav/sbp/ssr/OrbitClockBound.java b/java/src/com/swiftnav/sbp/ssr/OrbitClockBound.java index 6bc15cd51..55d8ea9ac 100644 --- a/java/src/com/swiftnav/sbp/ssr/OrbitClockBound.java +++ b/java/src/com/swiftnav/sbp/ssr/OrbitClockBound.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,51 +9,54 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class OrbitClockBound extends SBPStruct { - - /** - * Satellite ID. Similar to either RTCM DF068 (GPS), DF252 (Galileo), or DF488 (BDS) depending - * on the constellation. - */ + + /** Satellite ID. Similar to either RTCM DF068 (GPS), DF252 (Galileo), or DF488 + * (BDS) depending on the constellation. */ public int sat_id; - + /** Mean Radial. See Note 1. */ public int orb_radial_bound_mu; - + /** Mean Along-Track. See Note 1. */ public int orb_along_bound_mu; - + /** Mean Cross-Track. See Note 1. */ public int orb_cross_bound_mu; - + /** Standard Deviation Radial. See Note 2. */ public int orb_radial_bound_sig; - + /** Standard Deviation Along-Track. See Note 2. */ public int orb_along_bound_sig; - + /** Standard Deviation Cross-Track. See Note 2. */ public int orb_cross_bound_sig; - + /** Clock Bound Mean. See Note 1. */ public int clock_bound_mu; - + /** Clock Bound Standard Deviation. See Note 2. */ public int clock_bound_sig; + - public OrbitClockBound() {} + public OrbitClockBound () {} @Override public OrbitClockBound parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/OrbitClockBoundDegradation.java b/java/src/com/swiftnav/sbp/ssr/OrbitClockBoundDegradation.java index 563e3c21c..8cd1299ac 100644 --- a/java/src/com/swiftnav/sbp/ssr/OrbitClockBoundDegradation.java +++ b/java/src/com/swiftnav/sbp/ssr/OrbitClockBoundDegradation.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,45 +9,50 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class OrbitClockBoundDegradation extends SBPStruct { - + /** Orbit Bound Mean Radial First derivative. Range: 0-0.255 m/s */ public int orb_radial_bound_mu_dot; - + /** Orbit Bound Mean Along-Track First derivative. Range: 0-0.255 m/s */ public int orb_along_bound_mu_dot; - + /** Orbit Bound Mean Cross-Track First derivative. Range: 0-0.255 m/s */ public int orb_cross_bound_mu_dot; - + /** Orbit Bound Standard Deviation Radial First derivative. Range: 0-0.255 m/s */ public int orb_radial_bound_sig_dot; - + /** Orbit Bound Standard Deviation Along-Track First derivative. Range: 0-0.255 m/s */ public int orb_along_bound_sig_dot; - + /** Orbit Bound Standard Deviation Cross-Track First derivative. Range: 0-0.255 m/s */ public int orb_cross_bound_sig_dot; - + /** Clock Bound Mean First derivative. Range: 0-0.255 m/s */ public int clock_bound_mu_dot; - + /** Clock Bound Standard Deviation First derivative. Range: 0-0.255 m/s */ public int clock_bound_sig_dot; + - public OrbitClockBoundDegradation() {} + public OrbitClockBoundDegradation () {} @Override public OrbitClockBoundDegradation parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/PhaseBiasesContent.java b/java/src/com/swiftnav/sbp/ssr/PhaseBiasesContent.java index ecf34cb82..161214784 100644 --- a/java/src/com/swiftnav/sbp/ssr/PhaseBiasesContent.java +++ b/java/src/com/swiftnav/sbp/ssr/PhaseBiasesContent.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,36 +9,41 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class PhaseBiasesContent extends SBPStruct { - + /** Signal encoded following RTCM specifications (DF380, DF381, DF382 and DF467) */ public int code; - + /** Indicator for integer property */ public int integer_indicator; - + /** Indicator for two groups of Wide-Lane(s) integer property */ public int widelane_integer_indicator; - + /** Signal phase discontinuity counter. Increased for every discontinuity in phase. */ public int discontinuity_counter; - + /** Phase bias for specified signal */ public int bias; + - public PhaseBiasesContent() {} + public PhaseBiasesContent () {} @Override public PhaseBiasesContent parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/STECHeader.java b/java/src/com/swiftnav/sbp/ssr/STECHeader.java index 8113cf680..56e0eda9b 100644 --- a/java/src/com/swiftnav/sbp/ssr/STECHeader.java +++ b/java/src/com/swiftnav/sbp/ssr/STECHeader.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,44 +9,48 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class STECHeader extends SBPStruct { - + /** Unique identifier of the tile set this tile belongs to. */ public int tile_set_id; - + /** Unique identifier of this tile in the tile set. */ public int tile_id; - + /** GNSS reference time of the correction */ public GPSTimeSec time; - + /** Number of messages in the dataset */ public int num_msgs; - + /** Position of this message in the dataset */ public int seq_num; - - /** - * Update interval between consecutive corrections. Encoded following RTCM DF391 specification. - */ + + /** Update interval between consecutive corrections. Encoded following RTCM DF391 + * specification. */ public int update_interval; - + /** IOD of the SSR atmospheric correction */ public int iod_atmo; + - public STECHeader() {} + public STECHeader () {} @Override public STECHeader parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/STECHeaderDepA.java b/java/src/com/swiftnav/sbp/ssr/STECHeaderDepA.java index 9edcc0f28..95ffb38fe 100644 --- a/java/src/com/swiftnav/sbp/ssr/STECHeaderDepA.java +++ b/java/src/com/swiftnav/sbp/ssr/STECHeaderDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,38 +9,42 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class STECHeaderDepA extends SBPStruct { - + /** GNSS reference time of the correction */ public GPSTimeSec time; - + /** Number of messages in the dataset */ public int num_msgs; - + /** Position of this message in the dataset */ public int seq_num; - - /** - * Update interval between consecutive corrections. Encoded following RTCM DF391 specification. - */ + + /** Update interval between consecutive corrections. Encoded following RTCM DF391 + * specification. */ public int update_interval; - + /** IOD of the SSR atmospheric correction */ public int iod_atmo; + - public STECHeaderDepA() {} + public STECHeaderDepA () {} @Override public STECHeaderDepA parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/STECResidual.java b/java/src/com/swiftnav/sbp/ssr/STECResidual.java index 364f70101..fa2a9df11 100644 --- a/java/src/com/swiftnav/sbp/ssr/STECResidual.java +++ b/java/src/com/swiftnav/sbp/ssr/STECResidual.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,34 +9,37 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class STECResidual extends SBPStruct { - + /** space vehicle identifier */ public SvId sv_id; - + /** STEC residual */ public int residual; - - /** - * Standard deviation encoded using a similar method as RTCM DF389. The upper 3 bit are the - * class, the lower 5 bits are the value. Standard deviation [TECU] = (3^class * (1 + value/16) - * - 1) * 0.1 - */ + + /** Standard deviation encoded using a similar method as RTCM DF389. The upper 3 + * bit are the class, the lower 5 bits are the value. Standard deviation [TECU] = + * (3^class * (1 + value/16) - 1) * 0.1 */ public int stddev; + - public STECResidual() {} + public STECResidual () {} @Override public STECResidual parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/STECResidualNoStd.java b/java/src/com/swiftnav/sbp/ssr/STECResidualNoStd.java index 58d388569..c3a9c0079 100644 --- a/java/src/com/swiftnav/sbp/ssr/STECResidualNoStd.java +++ b/java/src/com/swiftnav/sbp/ssr/STECResidualNoStd.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,27 +9,32 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class STECResidualNoStd extends SBPStruct { - + /** space vehicle identifier */ public SvId sv_id; - + /** STEC residual */ public int residual; + - public STECResidualNoStd() {} + public STECResidualNoStd () {} @Override public STECResidualNoStd parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/STECSatElement.java b/java/src/com/swiftnav/sbp/ssr/STECSatElement.java index bd7709e1d..8ea133b55 100644 --- a/java/src/com/swiftnav/sbp/ssr/STECSatElement.java +++ b/java/src/com/swiftnav/sbp/ssr/STECSatElement.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,37 +9,37 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; public class STECSatElement extends SBPStruct { - + /** Unique space vehicle identifier */ public SvId sv_id; - - /** - * Quality of the STEC data. Encoded following RTCM DF389 specification but in units of TECU - * instead of m. - */ + + /** Quality of the STEC data. Encoded following RTCM DF389 specification but in + * units of TECU instead of m. */ public int stec_quality_indicator; - - /** - * Coefficients of the STEC polynomial in the order of C00, C01, C10, C11. C00 = 0.05 TECU, - * C01/C10 = 0.02 TECU/deg, C11 0.02 TECU/deg^2 - */ + + /** Coefficients of the STEC polynomial in the order of C00, C01, C10, C11. C00 = + * 0.05 TECU, C01/C10 = 0.02 TECU/deg, C11 0.02 TECU/deg^2 */ public int[] stec_coeff; + - public STECSatElement() {} + public STECSatElement () {} @Override public STECSatElement parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/STECSatElementIntegrity.java b/java/src/com/swiftnav/sbp/ssr/STECSatElementIntegrity.java index 0e81b2542..2f6b03bcc 100644 --- a/java/src/com/swiftnav/sbp/ssr/STECSatElementIntegrity.java +++ b/java/src/com/swiftnav/sbp/ssr/STECSatElementIntegrity.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,36 +9,41 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class STECSatElementIntegrity extends SBPStruct { - + /** STEC residuals (mean, stddev) */ public STECResidual stec_residual; - + /** Error Bound Mean. See Note 1. */ public int stec_bound_mu; - + /** Error Bound StDev. See Note 1. */ public int stec_bound_sig; - + /** Error Bound Mean First derivative. */ public int stec_bound_mu_dot; - + /** Error Bound StDev First derivative. */ public int stec_bound_sig_dot; + - public STECSatElementIntegrity() {} + public STECSatElementIntegrity () {} @Override public STECSatElementIntegrity parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/SatelliteAPC.java b/java/src/com/swiftnav/sbp/ssr/SatelliteAPC.java index fc66bb6ad..9d561f7b8 100644 --- a/java/src/com/swiftnav/sbp/ssr/SatelliteAPC.java +++ b/java/src/com/swiftnav/sbp/ssr/SatelliteAPC.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,43 +9,44 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import org.json.JSONArray; + import org.json.JSONObject; +import org.json.JSONArray; public class SatelliteAPC extends SBPStruct { - + /** GNSS signal identifier (16 bit) */ public GnssSignal sid; - + /** Additional satellite information */ public int sat_info; - + /** Satellite Code, as defined by IGS. Typically the space vehicle number. */ public int svn; - - /** - * Mean phase center offset, X Y and Z axes. See IGS ANTEX file format description for - * coordinate system definition. - */ + + /** Mean phase center offset, X Y and Z axes. See IGS ANTEX file format description + * for coordinate system definition. */ public int[] pco; - - /** - * Elevation dependent phase center variations. First element is 0 degrees separation from the Z - * axis, subsequent elements represent elevation variations in 1 degree increments. - */ + + /** Elevation dependent phase center variations. First element is 0 degrees + * separation from the Z axis, subsequent elements represent elevation variations + * in 1 degree increments. */ public int[] pcv; + - public SatelliteAPC() {} + public SatelliteAPC () {} @Override public SatelliteAPC parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/TroposphericDelayCorrection.java b/java/src/com/swiftnav/sbp/ssr/TroposphericDelayCorrection.java index 0e6bd9430..32a06eee8 100644 --- a/java/src/com/swiftnav/sbp/ssr/TroposphericDelayCorrection.java +++ b/java/src/com/swiftnav/sbp/ssr/TroposphericDelayCorrection.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,34 +9,37 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class TroposphericDelayCorrection extends SBPStruct { - + /** Hydrostatic vertical delay. Add 2.3 m to get actual value. */ public int hydro; - + /** Wet vertical delay. Add 0.252 m to get actual value. */ public int wet; - - /** - * Standard deviation encoded using a similar method as RTCM DF389. The upper 3 bit are the - * class, the lower 5 bits are the value. Standard deviation [mm] = (3^class * (1 + value/16) - - * 1) - */ + + /** Standard deviation encoded using a similar method as RTCM DF389. The upper 3 + * bit are the class, the lower 5 bits are the value. Standard deviation [mm] = + * (3^class * (1 + value/16) - 1) */ public int stddev; + - public TroposphericDelayCorrection() {} + public TroposphericDelayCorrection () {} @Override public TroposphericDelayCorrection parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/ssr/TroposphericDelayCorrectionNoStd.java b/java/src/com/swiftnav/sbp/ssr/TroposphericDelayCorrectionNoStd.java index 4bf6dfa50..c28aac8e5 100644 --- a/java/src/com/swiftnav/sbp/ssr/TroposphericDelayCorrectionNoStd.java +++ b/java/src/com/swiftnav/sbp/ssr/TroposphericDelayCorrectionNoStd.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,31 +9,35 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.ssr; // This file was auto-generated from yaml/swiftnav/sbp/ssr.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class TroposphericDelayCorrectionNoStd extends SBPStruct { - + /** Hydrostatic vertical delay */ public int hydro; - + /** Wet vertical delay */ public int wet; + - public TroposphericDelayCorrectionNoStd() {} + public TroposphericDelayCorrectionNoStd () {} @Override - public TroposphericDelayCorrectionNoStd parse(SBPMessage.Parser parser) - throws SBPBinaryException { + public TroposphericDelayCorrectionNoStd parse(SBPMessage.Parser parser) throws SBPBinaryException { /* Parse fields from binary */ hydro = parser.getS16(); wet = parser.getS8(); diff --git a/java/src/com/swiftnav/sbp/system/MsgCsacTelemetry.java b/java/src/com/swiftnav/sbp/system/MsgCsacTelemetry.java index d2b0b9804..7ad2a3739 100644 --- a/java/src/com/swiftnav/sbp/system/MsgCsacTelemetry.java +++ b/java/src/com/swiftnav/sbp/system/MsgCsacTelemetry.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_CSAC_TELEMETRY (0xFF04). +/** SBP class for message MSG_CSAC_TELEMETRY (0xFF04). * - *

You can have MSG_CSAC_TELEMETRY inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_CSAC_TELEMETRY inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The CSAC telemetry message has an implementation defined telemetry string from a device. It is - * not produced or available on general Swift Products. It is intended to be a low rate message for - * status purposes. - */ + * The CSAC telemetry message has an implementation defined telemetry string + * from a device. It is not produced or available on general Swift Products. + * It is intended to be a low rate message for status purposes. */ + public class MsgCsacTelemetry extends SBPMessage { public static final int TYPE = 0xFF04; - /** Index representing the type of telemetry in use. It is implementation defined. */ + + /** Index representing the type of telemetry in use. It is implementation + * defined. */ public int id; - + /** Comma separated list of values as defined by the index */ public String telemetry; + - public MsgCsacTelemetry(int sender) { - super(sender, TYPE); - } - - public MsgCsacTelemetry() { - super(TYPE); - } - - public MsgCsacTelemetry(SBPMessage msg) throws SBPBinaryException { + public MsgCsacTelemetry (int sender) { super(sender, TYPE); } + public MsgCsacTelemetry () { super(TYPE); } + public MsgCsacTelemetry (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgCsacTelemetry, expected 65284, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgCsacTelemetry, expected 65284, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ id = parser.getU8(); - telemetry = parser.getString(); + telemetry = parser.getString(); } @Override protected void build(Builder builder) { builder.putU8(id); - builder.putString(telemetry); + builder.putString(telemetry); } @Override diff --git a/java/src/com/swiftnav/sbp/system/MsgCsacTelemetryLabels.java b/java/src/com/swiftnav/sbp/system/MsgCsacTelemetryLabels.java index 980d243d0..7dce26b22 100644 --- a/java/src/com/swiftnav/sbp/system/MsgCsacTelemetryLabels.java +++ b/java/src/com/swiftnav/sbp/system/MsgCsacTelemetryLabels.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_CSAC_TELEMETRY_LABELS (0xFF05). +/** SBP class for message MSG_CSAC_TELEMETRY_LABELS (0xFF05). * - *

You can have MSG_CSAC_TELEMETRY_LABELS inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_CSAC_TELEMETRY_LABELS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The CSAC telemetry message provides labels for each member of the string produced by - * MSG_CSAC_TELEMETRY. It should be provided by a device at a lower rate than the - * MSG_CSAC_TELEMETRY. - */ + * The CSAC telemetry message provides labels for each member of the string + * produced by MSG_CSAC_TELEMETRY. It should be provided by a device at a + * lower rate than the MSG_CSAC_TELEMETRY. */ + public class MsgCsacTelemetryLabels extends SBPMessage { public static final int TYPE = 0xFF05; - /** Index representing the type of telemetry in use. It is implementation defined. */ + + /** Index representing the type of telemetry in use. It is implementation + * defined. */ public int id; - + /** Comma separated list of telemetry field values */ public String telemetry_labels; + - public MsgCsacTelemetryLabels(int sender) { - super(sender, TYPE); - } - - public MsgCsacTelemetryLabels() { - super(TYPE); - } - - public MsgCsacTelemetryLabels(SBPMessage msg) throws SBPBinaryException { + public MsgCsacTelemetryLabels (int sender) { super(sender, TYPE); } + public MsgCsacTelemetryLabels () { super(TYPE); } + public MsgCsacTelemetryLabels (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgCsacTelemetryLabels, expected 65285, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgCsacTelemetryLabels, expected 65285, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ id = parser.getU8(); - telemetry_labels = parser.getString(); + telemetry_labels = parser.getString(); } @Override protected void build(Builder builder) { builder.putU8(id); - builder.putString(telemetry_labels); + builder.putString(telemetry_labels); } @Override diff --git a/java/src/com/swiftnav/sbp/system/MsgDgnssStatus.java b/java/src/com/swiftnav/sbp/system/MsgDgnssStatus.java index f3ab30749..24b2170e9 100644 --- a/java/src/com/swiftnav/sbp/system/MsgDgnssStatus.java +++ b/java/src/com/swiftnav/sbp/system/MsgDgnssStatus.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,53 +9,55 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_DGNSS_STATUS (0xFF02). + +/** SBP class for message MSG_DGNSS_STATUS (0xFF02). * - *

You can have MSG_DGNSS_STATUS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_DGNSS_STATUS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message provides information about the receipt of Differential corrections. It is - * expected to be sent with each receipt of a complete corrections packet. - */ + * This message provides information about the receipt of Differential + * corrections. It is expected to be sent with each receipt of a complete + * corrections packet. */ + public class MsgDgnssStatus extends SBPMessage { public static final int TYPE = 0xFF02; + /** Status flags */ public int flags; - + /** Latency of observation receipt */ public int latency; - + /** Number of signals from base station */ public int num_signals; - + /** Corrections source string */ public String source; + - public MsgDgnssStatus(int sender) { - super(sender, TYPE); - } - - public MsgDgnssStatus() { - super(TYPE); - } - - public MsgDgnssStatus(SBPMessage msg) throws SBPBinaryException { + public MsgDgnssStatus (int sender) { super(sender, TYPE); } + public MsgDgnssStatus () { super(TYPE); } + public MsgDgnssStatus (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgDgnssStatus, expected 65282, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgDgnssStatus, expected 65282, actual " + msg.type); } @Override @@ -63,7 +66,7 @@ protected void parse(Parser parser) throws SBPBinaryException { flags = parser.getU8(); latency = parser.getU16(); num_signals = parser.getU8(); - source = parser.getString(); + source = parser.getString(); } @Override @@ -71,7 +74,7 @@ protected void build(Builder builder) { builder.putU8(flags); builder.putU16(latency); builder.putU8(num_signals); - builder.putString(source); + builder.putString(source); } @Override diff --git a/java/src/com/swiftnav/sbp/system/MsgGnssTimeOffset.java b/java/src/com/swiftnav/sbp/system/MsgGnssTimeOffset.java index af306f751..5efb8084c 100644 --- a/java/src/com/swiftnav/sbp/system/MsgGnssTimeOffset.java +++ b/java/src/com/swiftnav/sbp/system/MsgGnssTimeOffset.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,54 +9,55 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_GNSS_TIME_OFFSET (0xFF07). + +/** SBP class for message MSG_GNSS_TIME_OFFSET (0xFF07). * - *

You can have MSG_GNSS_TIME_OFFSET inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_GNSS_TIME_OFFSET inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The GNSS time offset message contains the information that is needed to translate messages - * tagged with a local timestamp (e.g. IMU or wheeltick messages) to GNSS time for the sender - * producing this message. - */ + * The GNSS time offset message contains the information that is needed to + * translate messages tagged with a local timestamp (e.g. IMU or wheeltick + * messages) to GNSS time for the sender producing this message. */ + public class MsgGnssTimeOffset extends SBPMessage { public static final int TYPE = 0xFF07; + /** Weeks portion of the time offset */ public int weeks; - + /** Milliseconds portion of the time offset */ public int milliseconds; - + /** Microseconds portion of the time offset */ public int microseconds; - + /** Status flags */ public int flags; + - public MsgGnssTimeOffset(int sender) { - super(sender, TYPE); - } - - public MsgGnssTimeOffset() { - super(TYPE); - } - - public MsgGnssTimeOffset(SBPMessage msg) throws SBPBinaryException { + public MsgGnssTimeOffset (int sender) { super(sender, TYPE); } + public MsgGnssTimeOffset () { super(TYPE); } + public MsgGnssTimeOffset (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgGnssTimeOffset, expected 65287, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgGnssTimeOffset, expected 65287, actual " + msg.type); } @Override @@ -64,7 +66,7 @@ protected void parse(Parser parser) throws SBPBinaryException { weeks = parser.getS16(); milliseconds = parser.getS32(); microseconds = parser.getS16(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override @@ -72,7 +74,7 @@ protected void build(Builder builder) { builder.putS16(weeks); builder.putS32(milliseconds); builder.putS16(microseconds); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/system/MsgGroupMeta.java b/java/src/com/swiftnav/sbp/system/MsgGroupMeta.java index 0c835113b..c00739c03 100644 --- a/java/src/com/swiftnav/sbp/system/MsgGroupMeta.java +++ b/java/src/com/swiftnav/sbp/system/MsgGroupMeta.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_GROUP_META (0xFF0A). + +/** SBP class for message MSG_GROUP_META (0xFF0A). * - *

You can have MSG_GROUP_META inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_GROUP_META inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This leading message lists the time metadata of the Solution Group. It also lists the atomic - * contents (i.e. types of messages included) of the Solution Group. - */ + * This leading message lists the time metadata of the Solution Group. It also + * lists the atomic contents (i.e. types of messages included) of the Solution + * Group. */ + public class MsgGroupMeta extends SBPMessage { public static final int TYPE = 0xFF0A; + /** Id of the Msgs Group, 0 is Unknown, 1 is Bestpos, 2 is Gnss */ public int group_id; - + /** Status flags (reserved) */ public int flags; - + /** Size of list group_msgs */ public int n_group_msgs; - - /** - * An in-order list of message types included in the Solution Group, including GROUP_META itself - */ + + /** An in-order list of message types included in the Solution Group, + * including GROUP_META itself */ public int[] group_msgs; + - public MsgGroupMeta(int sender) { - super(sender, TYPE); - } - - public MsgGroupMeta() { - super(TYPE); - } - - public MsgGroupMeta(SBPMessage msg) throws SBPBinaryException { + public MsgGroupMeta (int sender) { super(sender, TYPE); } + public MsgGroupMeta () { super(TYPE); } + public MsgGroupMeta (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgGroupMeta, expected 65290, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgGroupMeta, expected 65290, actual " + msg.type); } @Override @@ -66,7 +67,7 @@ protected void parse(Parser parser) throws SBPBinaryException { group_id = parser.getU8(); flags = parser.getU8(); n_group_msgs = parser.getU8(); - group_msgs = parser.getArrayofU16(); + group_msgs = parser.getArrayofU16(); } @Override @@ -74,7 +75,7 @@ protected void build(Builder builder) { builder.putU8(group_id); builder.putU8(flags); builder.putU8(n_group_msgs); - builder.putArrayofU16(group_msgs); + builder.putArrayofU16(group_msgs); } @Override diff --git a/java/src/com/swiftnav/sbp/system/MsgHeartbeat.java b/java/src/com/swiftnav/sbp/system/MsgHeartbeat.java index fc079f10d..52869fa07 100644 --- a/java/src/com/swiftnav/sbp/system/MsgHeartbeat.java +++ b/java/src/com/swiftnav/sbp/system/MsgHeartbeat.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_HEARTBEAT (0xFFFF). +/** SBP class for message MSG_HEARTBEAT (0xFFFF). * - *

You can have MSG_HEARTBEAT inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_HEARTBEAT inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The heartbeat message is sent periodically to inform the host or other attached devices that - * the system is running. It is used to monitor system malfunctions. It also contains status flags - * that indicate to the host the status of the system and whether it is operating correctly. - * Currently, the expected heartbeat interval is 1 sec. + * The heartbeat message is sent periodically to inform the host or other + * attached devices that the system is running. It is used to monitor system + * malfunctions. It also contains status flags that indicate to the host the + * status of the system and whether it is operating correctly. Currently, the + * expected heartbeat interval is 1 sec. * - *

The system error flag is used to indicate that an error has occurred in the system. To - * determine the source of the error, the remaining error flags should be inspected. - */ + * The system error flag is used to indicate that an error has occurred in the + * system. To determine the source of the error, the remaining error flags + * should be inspected. */ + public class MsgHeartbeat extends SBPMessage { public static final int TYPE = 0xFFFF; + /** Status flags */ public long flags; + - public MsgHeartbeat(int sender) { - super(sender, TYPE); - } - - public MsgHeartbeat() { - super(TYPE); - } - - public MsgHeartbeat(SBPMessage msg) throws SBPBinaryException { + public MsgHeartbeat (int sender) { super(sender, TYPE); } + public MsgHeartbeat () { super(TYPE); } + public MsgHeartbeat (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgHeartbeat, expected 65535, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgHeartbeat, expected 65535, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - flags = parser.getU32(); + flags = parser.getU32(); } @Override protected void build(Builder builder) { - builder.putU32(flags); + builder.putU32(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/system/MsgInsStatus.java b/java/src/com/swiftnav/sbp/system/MsgInsStatus.java index 053c9346a..c4246924d 100644 --- a/java/src/com/swiftnav/sbp/system/MsgInsStatus.java +++ b/java/src/com/swiftnav/sbp/system/MsgInsStatus.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,55 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_INS_STATUS (0xFF03). +/** SBP class for message MSG_INS_STATUS (0xFF03). * - *

You can have MSG_INS_STATUS inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_INS_STATUS inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The INS status message describes the state of the operation and initialization of the inertial - * navigation system. - */ + * The INS status message describes the state of the operation and + * initialization of the inertial navigation system. */ + public class MsgInsStatus extends SBPMessage { public static final int TYPE = 0xFF03; + /** Status flags */ public long flags; + - public MsgInsStatus(int sender) { - super(sender, TYPE); - } - - public MsgInsStatus() { - super(TYPE); - } - - public MsgInsStatus(SBPMessage msg) throws SBPBinaryException { + public MsgInsStatus (int sender) { super(sender, TYPE); } + public MsgInsStatus () { super(TYPE); } + public MsgInsStatus (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgInsStatus, expected 65283, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgInsStatus, expected 65283, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - flags = parser.getU32(); + flags = parser.getU32(); } @Override protected void build(Builder builder) { - builder.putU32(flags); + builder.putU32(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/system/MsgInsUpdates.java b/java/src/com/swiftnav/sbp/system/MsgInsUpdates.java index 982d7056c..0f9eb78f3 100644 --- a/java/src/com/swiftnav/sbp/system/MsgInsUpdates.java +++ b/java/src/com/swiftnav/sbp/system/MsgInsUpdates.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,63 +9,64 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_INS_UPDATES (0xFF06). +/** SBP class for message MSG_INS_UPDATES (0xFF06). * - *

You can have MSG_INS_UPDATES inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_INS_UPDATES inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The INS update status message contains information about executed and rejected INS updates. - * This message is expected to be extended in the future as new types of measurements are being - * added. - */ + * The INS update status message contains information about executed and + * rejected INS updates. This message is expected to be extended in the future + * as new types of measurements are being added. */ + public class MsgInsUpdates extends SBPMessage { public static final int TYPE = 0xFF06; + /** GPS Time of Week */ public long tow; - + /** GNSS position update status flags */ public int gnsspos; - + /** GNSS velocity update status flags */ public int gnssvel; - + /** Wheelticks update status flags */ public int wheelticks; - + /** Wheelticks update status flags */ public int speed; - + /** NHC update status flags */ public int nhc; - + /** Zero velocity update status flags */ public int zerovel; + - public MsgInsUpdates(int sender) { - super(sender, TYPE); - } - - public MsgInsUpdates() { - super(TYPE); - } - - public MsgInsUpdates(SBPMessage msg) throws SBPBinaryException { + public MsgInsUpdates (int sender) { super(sender, TYPE); } + public MsgInsUpdates () { super(TYPE); } + public MsgInsUpdates (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgInsUpdates, expected 65286, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgInsUpdates, expected 65286, actual " + msg.type); } @Override @@ -76,7 +78,7 @@ protected void parse(Parser parser) throws SBPBinaryException { wheelticks = parser.getU8(); speed = parser.getU8(); nhc = parser.getU8(); - zerovel = parser.getU8(); + zerovel = parser.getU8(); } @Override @@ -87,7 +89,7 @@ protected void build(Builder builder) { builder.putU8(wheelticks); builder.putU8(speed); builder.putU8(nhc); - builder.putU8(zerovel); + builder.putU8(zerovel); } @Override diff --git a/java/src/com/swiftnav/sbp/system/MsgPpsTime.java b/java/src/com/swiftnav/sbp/system/MsgPpsTime.java index 06e88df12..d09fab381 100644 --- a/java/src/com/swiftnav/sbp/system/MsgPpsTime.java +++ b/java/src/com/swiftnav/sbp/system/MsgPpsTime.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,69 +9,71 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import java.math.BigInteger; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_PPS_TIME (0xFF08). +/** SBP class for message MSG_PPS_TIME (0xFF08). * - *

You can have MSG_PPS_TIME inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_PPS_TIME inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The PPS time message contains the value of the sender's local time in microseconds at the - * moment a pulse is detected on the PPS input. This is to be used for synchronisation of sensor - * data sampled with a local timestamp (e.g. IMU or wheeltick messages) where GNSS time is unknown - * to the sender. + * The PPS time message contains the value of the sender's local time in + * microseconds at the moment a pulse is detected on the PPS input. This is to + * be used for synchronisation of sensor data sampled with a local timestamp + * (e.g. IMU or wheeltick messages) where GNSS time is unknown to the sender. * - *

The local time used to timestamp the PPS pulse must be generated by the same clock which is - * used to timestamp the IMU/wheel sensor data and should follow the same roll-over rules (i.e. it - * should roll over to zero after 604800 seconds). A separate MSG_PPS_TIME message should be sent - * for each source of sensor data which uses local timestamping. The sender ID for each of these - * MSG_PPS_TIME messages should match the sender ID of the respective sensor data. - */ + * The local time used to timestamp the PPS pulse must be generated by the + * same clock which is used to timestamp the IMU/wheel sensor data and should + * follow the same roll-over rules (i.e. it should roll over to zero after + * 604800 seconds). A separate MSG_PPS_TIME message should be sent for each + * source of sensor data which uses local timestamping. The sender ID for + * each of these MSG_PPS_TIME messages should match the sender ID of the + * respective sensor data. */ + public class MsgPpsTime extends SBPMessage { public static final int TYPE = 0xFF08; + /** Local time in microseconds */ public BigInteger time; - + /** Status flags */ public int flags; + - public MsgPpsTime(int sender) { - super(sender, TYPE); - } - - public MsgPpsTime() { - super(TYPE); - } - - public MsgPpsTime(SBPMessage msg) throws SBPBinaryException { + public MsgPpsTime (int sender) { super(sender, TYPE); } + public MsgPpsTime () { super(TYPE); } + public MsgPpsTime (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgPpsTime, expected 65288, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgPpsTime, expected 65288, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ time = parser.getU64(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override protected void build(Builder builder) { builder.putU64(time); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/system/MsgSensorAidEvent.java b/java/src/com/swiftnav/sbp/system/MsgSensorAidEvent.java index 1e7652823..e9de41c3b 100644 --- a/java/src/com/swiftnav/sbp/system/MsgSensorAidEvent.java +++ b/java/src/com/swiftnav/sbp/system/MsgSensorAidEvent.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,66 +9,68 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_SENSOR_AID_EVENT (0xFF09). +/** SBP class for message MSG_SENSOR_AID_EVENT (0xFF09). * - *

You can have MSG_SENSOR_AID_EVENT inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_SENSOR_AID_EVENT inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This diagnostic message contains state and update status information for all sensors that are - * being used by the fusion engine. This message will be generated asynchronously to the solution - * messages and will be emitted anytime a sensor update is being processed. - */ + * This diagnostic message contains state and update status information for + * all sensors that are being used by the fusion engine. This message will be + * generated asynchronously to the solution messages and will be emitted + * anytime a sensor update is being processed. */ + public class MsgSensorAidEvent extends SBPMessage { public static final int TYPE = 0xFF09; + /** Update timestamp in milliseconds. */ public long time; - + /** Sensor type */ public int sensor_type; - + /** Sensor identifier */ public int sensor_id; - + /** Reserved for future use */ public int sensor_state; - + /** Number of available measurements in this epoch */ public int n_available_meas; - + /** Number of attempted measurements in this epoch */ public int n_attempted_meas; - + /** Number of accepted measurements in this epoch */ public int n_accepted_meas; - + /** Reserved for future use */ public long flags; + - public MsgSensorAidEvent(int sender) { - super(sender, TYPE); - } - - public MsgSensorAidEvent() { - super(TYPE); - } - - public MsgSensorAidEvent(SBPMessage msg) throws SBPBinaryException { + public MsgSensorAidEvent (int sender) { super(sender, TYPE); } + public MsgSensorAidEvent () { super(TYPE); } + public MsgSensorAidEvent (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgSensorAidEvent, expected 65289, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgSensorAidEvent, expected 65289, actual " + msg.type); } @Override @@ -80,7 +83,7 @@ protected void parse(Parser parser) throws SBPBinaryException { n_available_meas = parser.getU8(); n_attempted_meas = parser.getU8(); n_accepted_meas = parser.getU8(); - flags = parser.getU32(); + flags = parser.getU32(); } @Override @@ -92,7 +95,7 @@ protected void build(Builder builder) { builder.putU8(n_available_meas); builder.putU8(n_attempted_meas); builder.putU8(n_accepted_meas); - builder.putU32(flags); + builder.putU32(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/system/MsgStartup.java b/java/src/com/swiftnav/sbp/system/MsgStartup.java index a4ff827ab..0571fb7dd 100644 --- a/java/src/com/swiftnav/sbp/system/MsgStartup.java +++ b/java/src/com/swiftnav/sbp/system/MsgStartup.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,51 +9,52 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_STARTUP (0xFF00). + +/** SBP class for message MSG_STARTUP (0xFF00). * - *

You can have MSG_STARTUP inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_STARTUP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The system start-up message is sent once on system start-up. It notifies the host or other - * attached devices that the system has started and is now ready to respond to commands or - * configuration requests. - */ + * The system start-up message is sent once on system start-up. It notifies + * the host or other attached devices that the system has started and is now + * ready to respond to commands or configuration requests. */ + public class MsgStartup extends SBPMessage { public static final int TYPE = 0xFF00; + /** Cause of startup */ public int cause; - + /** Startup type */ public int startup_type; - + /** Reserved */ public int reserved; + - public MsgStartup(int sender) { - super(sender, TYPE); - } - - public MsgStartup() { - super(TYPE); - } - - public MsgStartup(SBPMessage msg) throws SBPBinaryException { + public MsgStartup (int sender) { super(sender, TYPE); } + public MsgStartup () { super(TYPE); } + public MsgStartup (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgStartup, expected 65280, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgStartup, expected 65280, actual " + msg.type); } @Override @@ -60,14 +62,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ cause = parser.getU8(); startup_type = parser.getU8(); - reserved = parser.getU16(); + reserved = parser.getU16(); } @Override protected void build(Builder builder) { builder.putU8(cause); builder.putU8(startup_type); - builder.putU16(reserved); + builder.putU16(reserved); } @Override diff --git a/java/src/com/swiftnav/sbp/system/MsgStatusJournal.java b/java/src/com/swiftnav/sbp/system/MsgStatusJournal.java index bd0ce5327..d7c354122 100644 --- a/java/src/com/swiftnav/sbp/system/MsgStatusJournal.java +++ b/java/src/com/swiftnav/sbp/system/MsgStatusJournal.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,60 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_STATUS_JOURNAL (0xFFFD). + +/** SBP class for message MSG_STATUS_JOURNAL (0xFFFD). * - *

You can have MSG_STATUS_JOURNAL inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_STATUS_JOURNAL inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The status journal message contains past status reports (see MSG_STATUS_REPORT) and functions - * as a error/event storage for telemetry purposes. - */ + * The status journal message contains past status reports (see + * MSG_STATUS_REPORT) and functions as a error/event storage for telemetry + * purposes. */ + public class MsgStatusJournal extends SBPMessage { public static final int TYPE = 0xFFFD; + /** Identity of reporting system */ public int reporting_system; - + /** SBP protocol version */ public int sbp_version; - + /** Total number of status reports sent since system startup */ public long total_status_reports; - - /** - * Index and number of messages in this sequence. First nibble is the size of the sequence (n), - * second nibble is the zero-indexed counter (ith packet of n) - */ + + /** Index and number of messages in this sequence. First nibble is the + * size of the sequence (n), second nibble is the zero-indexed counter + * (ith packet of n) */ public int sequence_descriptor; - + /** Status journal */ public StatusJournalItem[] journal; + - public MsgStatusJournal(int sender) { - super(sender, TYPE); - } - - public MsgStatusJournal() { - super(TYPE); - } - - public MsgStatusJournal(SBPMessage msg) throws SBPBinaryException { + public MsgStatusJournal (int sender) { super(sender, TYPE); } + public MsgStatusJournal () { super(TYPE); } + public MsgStatusJournal (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgStatusJournal, expected 65533, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgStatusJournal, expected 65533, actual " + msg.type); } @Override @@ -71,7 +72,7 @@ protected void parse(Parser parser) throws SBPBinaryException { sbp_version = parser.getU16(); total_status_reports = parser.getU32(); sequence_descriptor = parser.getU8(); - journal = parser.getArray(StatusJournalItem.class); + journal = parser.getArray(StatusJournalItem.class); } @Override @@ -80,7 +81,7 @@ protected void build(Builder builder) { builder.putU16(sbp_version); builder.putU32(total_status_reports); builder.putU8(sequence_descriptor); - builder.putArray(journal); + builder.putArray(journal); } @Override diff --git a/java/src/com/swiftnav/sbp/system/MsgStatusReport.java b/java/src/com/swiftnav/sbp/system/MsgStatusReport.java index f49ee180c..a16d1e75d 100644 --- a/java/src/com/swiftnav/sbp/system/MsgStatusReport.java +++ b/java/src/com/swiftnav/sbp/system/MsgStatusReport.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,61 +9,63 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_STATUS_REPORT (0xFFFE). + +/** SBP class for message MSG_STATUS_REPORT (0xFFFE). * - *

You can have MSG_STATUS_REPORT inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_STATUS_REPORT inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The status report is sent periodically to inform the host or other attached devices that the - * system is running. It is used to monitor system malfunctions. It contains status reports that - * indicate to the host the status of each subsystem and whether it is operating correctly. + * The status report is sent periodically to inform the host or other attached + * devices that the system is running. It is used to monitor system + * malfunctions. It contains status reports that indicate to the host the + * status of each subsystem and whether it is operating correctly. * - *

Interpretation of the subsystem specific status code is product dependent, but if the generic - * status code is initializing, it should be ignored. Refer to product documentation for details. - */ + * Interpretation of the subsystem specific status code is product dependent, + * but if the generic status code is initializing, it should be ignored. + * Refer to product documentation for details. */ + public class MsgStatusReport extends SBPMessage { public static final int TYPE = 0xFFFE; + /** Identity of reporting system */ public int reporting_system; - + /** SBP protocol version */ public int sbp_version; - + /** Increments on each status report sent */ public long sequence; - + /** Number of seconds since system start-up */ public long uptime; - + /** Reported status of individual subsystems */ public SubSystemReport[] status; + - public MsgStatusReport(int sender) { - super(sender, TYPE); - } - - public MsgStatusReport() { - super(TYPE); - } - - public MsgStatusReport(SBPMessage msg) throws SBPBinaryException { + public MsgStatusReport (int sender) { super(sender, TYPE); } + public MsgStatusReport () { super(TYPE); } + public MsgStatusReport (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgStatusReport, expected 65534, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgStatusReport, expected 65534, actual " + msg.type); } @Override @@ -72,7 +75,7 @@ protected void parse(Parser parser) throws SBPBinaryException { sbp_version = parser.getU16(); sequence = parser.getU32(); uptime = parser.getU32(); - status = parser.getArray(SubSystemReport.class); + status = parser.getArray(SubSystemReport.class); } @Override @@ -81,7 +84,7 @@ protected void build(Builder builder) { builder.putU16(sbp_version); builder.putU32(sequence); builder.putU32(uptime); - builder.putArray(status); + builder.putArray(status); } @Override diff --git a/java/src/com/swiftnav/sbp/system/StatusJournalItem.java b/java/src/com/swiftnav/sbp/system/StatusJournalItem.java index 0b4755799..a2780b2df 100644 --- a/java/src/com/swiftnav/sbp/system/StatusJournalItem.java +++ b/java/src/com/swiftnav/sbp/system/StatusJournalItem.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,25 +9,30 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class StatusJournalItem extends SBPStruct { - + /** Milliseconds since system startup */ public long uptime; - + public SubSystemReport report; + - public StatusJournalItem() {} + public StatusJournalItem () {} @Override public StatusJournalItem parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/system/SubSystemReport.java b/java/src/com/swiftnav/sbp/system/SubSystemReport.java index 77b0a8e50..84de625cd 100644 --- a/java/src/com/swiftnav/sbp/system/SubSystemReport.java +++ b/java/src/com/swiftnav/sbp/system/SubSystemReport.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,29 +9,34 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.system; // This file was auto-generated from yaml/swiftnav/sbp/system.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; public class SubSystemReport extends SBPStruct { - + /** Identity of reporting subsystem */ public int component; - + /** Generic form status report */ public int generic; - + /** Subsystem specific status code */ public int specific; + - public SubSystemReport() {} + public SubSystemReport () {} @Override public SubSystemReport parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/telemetry/MsgTelSv.java b/java/src/com/swiftnav/sbp/telemetry/MsgTelSv.java index 966bf6925..3bbae52a7 100644 --- a/java/src/com/swiftnav/sbp/telemetry/MsgTelSv.java +++ b/java/src/com/swiftnav/sbp/telemetry/MsgTelSv.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,60 +9,60 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.telemetry; // This file was auto-generated from yaml/swiftnav/sbp/telemetry.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_TEL_SV (0x0120). + +/** SBP class for message MSG_TEL_SV (0x0120). * - *

You can have MSG_TEL_SV inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_TEL_SV inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message includes telemetry pertinent to satellite signals available to Starling. - */ + * This message includes telemetry pertinent to satellite signals available to + * Starling. */ + public class MsgTelSv extends SBPMessage { public static final int TYPE = 0x0120; + /** GPS week number */ public int wn; - + /** GPS Time of Week */ public long tow; - - /** - * Total number of observations. First nibble is the size of the sequence (n), second nibble is - * the zero-indexed counter (ith packet of n) - */ + + /** Total number of observations. First nibble is the size of the sequence + * (n), second nibble is the zero-indexed counter (ith packet of n) */ public int n_obs; - - /** Flags to identify the filter type from which the telemetry is reported from */ + + /** Flags to identify the filter type from which the telemetry is reported + * from */ public int origin_flags; - + /** Array of per-signal telemetry entries */ public TelemetrySV[] sv_tel; + - public MsgTelSv(int sender) { - super(sender, TYPE); - } - - public MsgTelSv() { - super(TYPE); - } - - public MsgTelSv(SBPMessage msg) throws SBPBinaryException { + public MsgTelSv (int sender) { super(sender, TYPE); } + public MsgTelSv () { super(TYPE); } + public MsgTelSv (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgTelSv, expected 288, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgTelSv, expected 288, actual " + msg.type); } @Override @@ -71,7 +72,7 @@ protected void parse(Parser parser) throws SBPBinaryException { tow = parser.getU32(); n_obs = parser.getU8(); origin_flags = parser.getU8(); - sv_tel = parser.getArray(TelemetrySV.class); + sv_tel = parser.getArray(TelemetrySV.class); } @Override @@ -80,7 +81,7 @@ protected void build(Builder builder) { builder.putU32(tow); builder.putU8(n_obs); builder.putU8(origin_flags); - builder.putArray(sv_tel); + builder.putArray(sv_tel); } @Override diff --git a/java/src/com/swiftnav/sbp/telemetry/TelemetrySV.java b/java/src/com/swiftnav/sbp/telemetry/TelemetrySV.java index e381d81f2..1676f228b 100644 --- a/java/src/com/swiftnav/sbp/telemetry/TelemetrySV.java +++ b/java/src/com/swiftnav/sbp/telemetry/TelemetrySV.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,48 +9,53 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.telemetry; // This file was auto-generated from yaml/swiftnav/sbp/telemetry.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class TelemetrySV extends SBPStruct { - + /** Azimuth angle (range 0..179) */ public int az; - + /** Elevation angle (range -90..90) */ public int el; - + /** Observation availability at filter update */ public int availability_flags; - + /** Pseudorange observation residual */ public int pseudorange_residual; - + /** Carrier-phase or carrier-phase-derived observation residual */ public int phase_residual; - + /** Reports if observation is marked as an outlier and is excluded from the update */ public int outlier_flags; - + /** Ephemeris metadata */ public int ephemeris_flags; - + /** Reserved */ public int correction_flags; - + /** GNSS signal identifier (16 bit) */ public GnssSignal sid; + - public TelemetrySV() {} + public TelemetrySV () {} @Override public TelemetrySV parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/tracking/MeasurementState.java b/java/src/com/swiftnav/sbp/tracking/MeasurementState.java index 04be5658b..329225c88 100644 --- a/java/src/com/swiftnav/sbp/tracking/MeasurementState.java +++ b/java/src/com/swiftnav/sbp/tracking/MeasurementState.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,27 +9,33 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class MeasurementState extends SBPStruct { - - /** Measurement Engine GNSS signal being tracked (carries either Glonass FCN or SLOT) */ + + /** Measurement Engine GNSS signal being tracked (carries either Glonass FCN or + * SLOT) */ public GnssSignal mesid; - - /** Carrier-to-Noise density. Zero implies invalid cn0. */ + + /** Carrier-to-Noise density. Zero implies invalid cn0. */ public int cn0; + - public MeasurementState() {} + public MeasurementState () {} @Override public MeasurementState parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/tracking/MsgMeasurementState.java b/java/src/com/swiftnav/sbp/tracking/MsgMeasurementState.java index 0f6ee4303..dbef14c19 100644 --- a/java/src/com/swiftnav/sbp/tracking/MsgMeasurementState.java +++ b/java/src/com/swiftnav/sbp/tracking/MsgMeasurementState.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_MEASUREMENT_STATE (0x0061). +/** SBP class for message MSG_MEASUREMENT_STATE (0x0061). * - *

You can have MSG_MEASUREMENT_STATE inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_MEASUREMENT_STATE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The tracking message returns a variable-length array of tracking channel states. It reports - * status and carrier-to-noise density measurements for all tracked satellites. - */ + * The tracking message returns a variable-length array of tracking channel + * states. It reports status and carrier-to-noise density measurements for all + * tracked satellites. */ + public class MsgMeasurementState extends SBPMessage { public static final int TYPE = 0x0061; + /** ME signal tracking channel state */ public MeasurementState[] states; + - public MsgMeasurementState(int sender) { - super(sender, TYPE); - } - - public MsgMeasurementState() { - super(TYPE); - } - - public MsgMeasurementState(SBPMessage msg) throws SBPBinaryException { + public MsgMeasurementState (int sender) { super(sender, TYPE); } + public MsgMeasurementState () { super(TYPE); } + public MsgMeasurementState (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgMeasurementState, expected 97, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgMeasurementState, expected 97, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - states = parser.getArray(MeasurementState.class); + states = parser.getArray(MeasurementState.class); } @Override protected void build(Builder builder) { - builder.putArray(states); + builder.putArray(states); } @Override diff --git a/java/src/com/swiftnav/sbp/tracking/MsgTrackingIq.java b/java/src/com/swiftnav/sbp/tracking/MsgTrackingIq.java index 0e67f177c..ca796701e 100644 --- a/java/src/com/swiftnav/sbp/tracking/MsgTrackingIq.java +++ b/java/src/com/swiftnav/sbp/tracking/MsgTrackingIq.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,51 +9,52 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_TRACKING_IQ (0x002D). + +/** SBP class for message MSG_TRACKING_IQ (0x002D). * - *

You can have MSG_TRACKING_IQ inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_TRACKING_IQ inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

When enabled, a tracking channel can output the correlations at each update interval. - */ + * When enabled, a tracking channel can output the correlations at each update + * interval. */ + public class MsgTrackingIq extends SBPMessage { public static final int TYPE = 0x002D; + /** Tracking channel of origin */ public int channel; - + /** GNSS signal identifier */ public GnssSignal sid; - + /** Early, Prompt and Late correlations */ public TrackingChannelCorrelation[] corrs; + - public MsgTrackingIq(int sender) { - super(sender, TYPE); - } - - public MsgTrackingIq() { - super(TYPE); - } - - public MsgTrackingIq(SBPMessage msg) throws SBPBinaryException { + public MsgTrackingIq (int sender) { super(sender, TYPE); } + public MsgTrackingIq () { super(TYPE); } + public MsgTrackingIq (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgTrackingIq, expected 45, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgTrackingIq, expected 45, actual " + msg.type); } @Override @@ -60,14 +62,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ channel = parser.getU8(); sid = new GnssSignal().parse(parser); - corrs = parser.getArray(TrackingChannelCorrelation.class, 3); + corrs = parser.getArray(TrackingChannelCorrelation.class, 3); } @Override protected void build(Builder builder) { builder.putU8(channel); sid.build(builder); - builder.putArray(corrs, 3); + builder.putArray(corrs, 3); } @Override diff --git a/java/src/com/swiftnav/sbp/tracking/MsgTrackingIqDepA.java b/java/src/com/swiftnav/sbp/tracking/MsgTrackingIqDepA.java index c46f7e3f5..c588064d3 100644 --- a/java/src/com/swiftnav/sbp/tracking/MsgTrackingIqDepA.java +++ b/java/src/com/swiftnav/sbp/tracking/MsgTrackingIqDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,51 +9,51 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_TRACKING_IQ_DEP_A (0x001C). + +/** SBP class for message MSG_TRACKING_IQ_DEP_A (0x001C). * - *

You can have MSG_TRACKING_IQ_DEP_A inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_TRACKING_IQ_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgTrackingIqDepA extends SBPMessage { public static final int TYPE = 0x001C; + /** Tracking channel of origin */ public int channel; - + /** GNSS signal identifier */ public GnssSignalDep sid; - + /** Early, Prompt and Late correlations */ public TrackingChannelCorrelationDep[] corrs; + - public MsgTrackingIqDepA(int sender) { - super(sender, TYPE); - } - - public MsgTrackingIqDepA() { - super(TYPE); - } - - public MsgTrackingIqDepA(SBPMessage msg) throws SBPBinaryException { + public MsgTrackingIqDepA (int sender) { super(sender, TYPE); } + public MsgTrackingIqDepA () { super(TYPE); } + public MsgTrackingIqDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgTrackingIqDepA, expected 28, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgTrackingIqDepA, expected 28, actual " + msg.type); } @Override @@ -60,14 +61,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ channel = parser.getU8(); sid = new GnssSignalDep().parse(parser); - corrs = parser.getArray(TrackingChannelCorrelationDep.class, 3); + corrs = parser.getArray(TrackingChannelCorrelationDep.class, 3); } @Override protected void build(Builder builder) { builder.putU8(channel); sid.build(builder); - builder.putArray(corrs, 3); + builder.putArray(corrs, 3); } @Override diff --git a/java/src/com/swiftnav/sbp/tracking/MsgTrackingIqDepB.java b/java/src/com/swiftnav/sbp/tracking/MsgTrackingIqDepB.java index c8ba55bab..e1f3e9535 100644 --- a/java/src/com/swiftnav/sbp/tracking/MsgTrackingIqDepB.java +++ b/java/src/com/swiftnav/sbp/tracking/MsgTrackingIqDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,51 +9,51 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_TRACKING_IQ_DEP_B (0x002C). + +/** SBP class for message MSG_TRACKING_IQ_DEP_B (0x002C). * - *

You can have MSG_TRACKING_IQ_DEP_B inherent its fields directly from an inherited SBP object, - * or construct it inline using a dict of its fields. + * You can have MSG_TRACKING_IQ_DEP_B inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgTrackingIqDepB extends SBPMessage { public static final int TYPE = 0x002C; + /** Tracking channel of origin */ public int channel; - + /** GNSS signal identifier */ public GnssSignal sid; - + /** Early, Prompt and Late correlations */ public TrackingChannelCorrelationDep[] corrs; + - public MsgTrackingIqDepB(int sender) { - super(sender, TYPE); - } - - public MsgTrackingIqDepB() { - super(TYPE); - } - - public MsgTrackingIqDepB(SBPMessage msg) throws SBPBinaryException { + public MsgTrackingIqDepB (int sender) { super(sender, TYPE); } + public MsgTrackingIqDepB () { super(TYPE); } + public MsgTrackingIqDepB (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgTrackingIqDepB, expected 44, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgTrackingIqDepB, expected 44, actual " + msg.type); } @Override @@ -60,14 +61,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ channel = parser.getU8(); sid = new GnssSignal().parse(parser); - corrs = parser.getArray(TrackingChannelCorrelationDep.class, 3); + corrs = parser.getArray(TrackingChannelCorrelationDep.class, 3); } @Override protected void build(Builder builder) { builder.putU8(channel); sid.build(builder); - builder.putArray(corrs, 3); + builder.putArray(corrs, 3); } @Override diff --git a/java/src/com/swiftnav/sbp/tracking/MsgTrackingState.java b/java/src/com/swiftnav/sbp/tracking/MsgTrackingState.java index b491addbf..242b0b42a 100644 --- a/java/src/com/swiftnav/sbp/tracking/MsgTrackingState.java +++ b/java/src/com/swiftnav/sbp/tracking/MsgTrackingState.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,57 +9,58 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_TRACKING_STATE (0x0041). +/** SBP class for message MSG_TRACKING_STATE (0x0041). * - *

You can have MSG_TRACKING_STATE inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_TRACKING_STATE inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The tracking message returns a variable-length array of tracking channel states. It reports - * status and carrier-to-noise density measurements for all tracked satellites. - */ + * The tracking message returns a variable-length array of tracking channel + * states. It reports status and carrier-to-noise density measurements for all + * tracked satellites. */ + public class MsgTrackingState extends SBPMessage { public static final int TYPE = 0x0041; + /** Signal tracking channel state */ public TrackingChannelState[] states; + - public MsgTrackingState(int sender) { - super(sender, TYPE); - } - - public MsgTrackingState() { - super(TYPE); - } - - public MsgTrackingState(SBPMessage msg) throws SBPBinaryException { + public MsgTrackingState (int sender) { super(sender, TYPE); } + public MsgTrackingState () { super(TYPE); } + public MsgTrackingState (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgTrackingState, expected 65, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgTrackingState, expected 65, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - states = parser.getArray(TrackingChannelState.class); + states = parser.getArray(TrackingChannelState.class); } @Override protected void build(Builder builder) { - builder.putArray(states); + builder.putArray(states); } @Override diff --git a/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDepA.java b/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDepA.java index 6309d79dc..36e2919ee 100644 --- a/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDepA.java +++ b/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_TRACKING_STATE_DEP_A (0x0016). +/** SBP class for message MSG_TRACKING_STATE_DEP_A (0x0016). * - *

You can have MSG_TRACKING_STATE_DEP_A inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_TRACKING_STATE_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgTrackingStateDepA extends SBPMessage { public static final int TYPE = 0x0016; + /** Satellite tracking channel state */ public TrackingChannelStateDepA[] states; + - public MsgTrackingStateDepA(int sender) { - super(sender, TYPE); - } - - public MsgTrackingStateDepA() { - super(TYPE); - } - - public MsgTrackingStateDepA(SBPMessage msg) throws SBPBinaryException { + public MsgTrackingStateDepA (int sender) { super(sender, TYPE); } + public MsgTrackingStateDepA () { super(TYPE); } + public MsgTrackingStateDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgTrackingStateDepA, expected 22, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgTrackingStateDepA, expected 22, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - states = parser.getArray(TrackingChannelStateDepA.class); + states = parser.getArray(TrackingChannelStateDepA.class); } @Override protected void build(Builder builder) { - builder.putArray(states); + builder.putArray(states); } @Override diff --git a/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDepB.java b/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDepB.java index 67624fb98..72a7ff070 100644 --- a/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDepB.java +++ b/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_TRACKING_STATE_DEP_B (0x0013). +/** SBP class for message MSG_TRACKING_STATE_DEP_B (0x0013). * - *

You can have MSG_TRACKING_STATE_DEP_B inherent its fields directly from an inherited SBP - * object, or construct it inline using a dict of its fields. + * You can have MSG_TRACKING_STATE_DEP_B inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgTrackingStateDepB extends SBPMessage { public static final int TYPE = 0x0013; + /** Signal tracking channel state */ public TrackingChannelStateDepB[] states; + - public MsgTrackingStateDepB(int sender) { - super(sender, TYPE); - } - - public MsgTrackingStateDepB() { - super(TYPE); - } - - public MsgTrackingStateDepB(SBPMessage msg) throws SBPBinaryException { + public MsgTrackingStateDepB (int sender) { super(sender, TYPE); } + public MsgTrackingStateDepB () { super(TYPE); } + public MsgTrackingStateDepB (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgTrackingStateDepB, expected 19, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgTrackingStateDepB, expected 19, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - states = parser.getArray(TrackingChannelStateDepB.class); + states = parser.getArray(TrackingChannelStateDepB.class); } @Override protected void build(Builder builder) { - builder.putArray(states); + builder.putArray(states); } @Override diff --git a/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDetailedDep.java b/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDetailedDep.java index de94216f8..041ad143c 100644 --- a/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDetailedDep.java +++ b/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDetailedDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,120 +9,112 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import java.math.BigInteger; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_TRACKING_STATE_DETAILED_DEP (0x0011). +/** SBP class for message MSG_TRACKING_STATE_DETAILED_DEP (0x0011). * - *

You can have MSG_TRACKING_STATE_DETAILED_DEP inherent its fields directly from an inherited - * SBP object, or construct it inline using a dict of its fields. + * You can have MSG_TRACKING_STATE_DETAILED_DEP inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Deprecated. - */ + * Deprecated. */ + public class MsgTrackingStateDetailedDep extends SBPMessage { public static final int TYPE = 0x0011; + /** Receiver clock time. */ public BigInteger recv_time; - - /** - * Time of transmission of signal from satellite. TOW only valid when TOW status is decoded or - * propagated. WN only valid when week number valid flag is set. - */ + + /** Time of transmission of signal from satellite. TOW only valid when TOW + * status is decoded or propagated. WN only valid when week number valid + * flag is set. */ public GPSTimeDep tot; - - /** Pseudorange observation. Valid only when pseudorange valid flag is set. */ + + /** Pseudorange observation. Valid only when pseudorange valid flag is + * set. */ public long P; - - /** - * Pseudorange observation standard deviation. Valid only when pseudorange valid flag is set. - */ + + /** Pseudorange observation standard deviation. Valid only when + * pseudorange valid flag is set. */ public int P_std; - - /** - * Carrier phase observation with typical sign convention. Valid only when PLL pessimistic lock - * is achieved. - */ + + /** Carrier phase observation with typical sign convention. Valid only + * when PLL pessimistic lock is achieved. */ public CarrierPhase L; - + /** Carrier-to-Noise density */ public int cn0; - - /** - * Lock time. It is encoded according to DF402 from the RTCM 10403.2 Amendment 2 specification. - * Valid values range from 0 to 15. - */ + + /** Lock time. It is encoded according to DF402 from the RTCM 10403.2 + * Amendment 2 specification. Valid values range from 0 to 15. */ public int lock; - + /** GNSS signal identifier. */ public GnssSignalDep sid; - + /** Carrier Doppler frequency. */ public int doppler; - + /** Carrier Doppler frequency standard deviation. */ public int doppler_std; - - /** - * Number of seconds of continuous tracking. Specifies how much time signal is in continuous - * track. - */ + + /** Number of seconds of continuous tracking. Specifies how much time + * signal is in continuous track. */ public long uptime; - + /** TCXO clock offset. Valid only when valid clock valid flag is set. */ public int clock_offset; - + /** TCXO clock drift. Valid only when valid clock valid flag is set. */ public int clock_drift; - + /** Early-Prompt (EP) and Prompt-Late (PL) correlators spacing. */ public int corr_spacing; - + /** Acceleration. Valid only when acceleration valid flag is set. */ public int acceleration; - + /** Synchronization status flags. */ public int sync_flags; - + /** TOW status flags. */ public int tow_flags; - + /** Tracking loop status flags. */ public int track_flags; - + /** Navigation data status flags. */ public int nav_flags; - + /** Parameters sets flags. */ public int pset_flags; - + /** Miscellaneous flags. */ public int misc_flags; + - public MsgTrackingStateDetailedDep(int sender) { - super(sender, TYPE); - } - - public MsgTrackingStateDetailedDep() { - super(TYPE); - } - - public MsgTrackingStateDetailedDep(SBPMessage msg) throws SBPBinaryException { + public MsgTrackingStateDetailedDep (int sender) { super(sender, TYPE); } + public MsgTrackingStateDetailedDep () { super(TYPE); } + public MsgTrackingStateDetailedDep (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgTrackingStateDetailedDep, expected 17, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgTrackingStateDetailedDep, expected 17, actual " + msg.type); } @Override @@ -147,7 +140,7 @@ protected void parse(Parser parser) throws SBPBinaryException { track_flags = parser.getU8(); nav_flags = parser.getU8(); pset_flags = parser.getU8(); - misc_flags = parser.getU8(); + misc_flags = parser.getU8(); } @Override @@ -172,7 +165,7 @@ protected void build(Builder builder) { builder.putU8(track_flags); builder.putU8(nav_flags); builder.putU8(pset_flags); - builder.putU8(misc_flags); + builder.putU8(misc_flags); } @Override diff --git a/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDetailedDepA.java b/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDetailedDepA.java index d6b2cf3dc..67ec2b33d 100644 --- a/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDetailedDepA.java +++ b/java/src/com/swiftnav/sbp/tracking/MsgTrackingStateDetailedDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,121 +9,113 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; -import java.math.BigInteger; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_TRACKING_STATE_DETAILED_DEP_A (0x0021). +/** SBP class for message MSG_TRACKING_STATE_DETAILED_DEP_A (0x0021). * - *

You can have MSG_TRACKING_STATE_DETAILED_DEP_A inherent its fields directly from an inherited - * SBP object, or construct it inline using a dict of its fields. + * You can have MSG_TRACKING_STATE_DETAILED_DEP_A inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

The tracking message returns a set tracking channel parameters for a single tracking channel - * useful for debugging issues. - */ + * The tracking message returns a set tracking channel parameters for a single + * tracking channel useful for debugging issues. */ + public class MsgTrackingStateDetailedDepA extends SBPMessage { public static final int TYPE = 0x0021; + /** Receiver clock time. */ public BigInteger recv_time; - - /** - * Time of transmission of signal from satellite. TOW only valid when TOW status is decoded or - * propagated. WN only valid when week number valid flag is set. - */ + + /** Time of transmission of signal from satellite. TOW only valid when TOW + * status is decoded or propagated. WN only valid when week number valid + * flag is set. */ public GPSTime tot; - - /** Pseudorange observation. Valid only when pseudorange valid flag is set. */ + + /** Pseudorange observation. Valid only when pseudorange valid flag is + * set. */ public long P; - - /** - * Pseudorange observation standard deviation. Valid only when pseudorange valid flag is set. - */ + + /** Pseudorange observation standard deviation. Valid only when + * pseudorange valid flag is set. */ public int P_std; - - /** - * Carrier phase observation with typical sign convention. Valid only when PLL pessimistic lock - * is achieved. - */ + + /** Carrier phase observation with typical sign convention. Valid only + * when PLL pessimistic lock is achieved. */ public CarrierPhase L; - + /** Carrier-to-Noise density */ public int cn0; - - /** - * Lock time. It is encoded according to DF402 from the RTCM 10403.2 Amendment 2 specification. - * Valid values range from 0 to 15. - */ + + /** Lock time. It is encoded according to DF402 from the RTCM 10403.2 + * Amendment 2 specification. Valid values range from 0 to 15. */ public int lock; - + /** GNSS signal identifier. */ public GnssSignal sid; - + /** Carrier Doppler frequency. */ public int doppler; - + /** Carrier Doppler frequency standard deviation. */ public int doppler_std; - - /** - * Number of seconds of continuous tracking. Specifies how much time signal is in continuous - * track. - */ + + /** Number of seconds of continuous tracking. Specifies how much time + * signal is in continuous track. */ public long uptime; - + /** TCXO clock offset. Valid only when valid clock valid flag is set. */ public int clock_offset; - + /** TCXO clock drift. Valid only when valid clock valid flag is set. */ public int clock_drift; - + /** Early-Prompt (EP) and Prompt-Late (PL) correlators spacing. */ public int corr_spacing; - + /** Acceleration. Valid only when acceleration valid flag is set. */ public int acceleration; - + /** Synchronization status flags. */ public int sync_flags; - + /** TOW status flags. */ public int tow_flags; - + /** Tracking loop status flags. */ public int track_flags; - + /** Navigation data status flags. */ public int nav_flags; - + /** Parameters sets flags. */ public int pset_flags; - + /** Miscellaneous flags. */ public int misc_flags; + - public MsgTrackingStateDetailedDepA(int sender) { - super(sender, TYPE); - } - - public MsgTrackingStateDetailedDepA() { - super(TYPE); - } - - public MsgTrackingStateDetailedDepA(SBPMessage msg) throws SBPBinaryException { + public MsgTrackingStateDetailedDepA (int sender) { super(sender, TYPE); } + public MsgTrackingStateDetailedDepA () { super(TYPE); } + public MsgTrackingStateDetailedDepA (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgTrackingStateDetailedDepA, expected 33, actual " - + msg.type); + throw new SBPBinaryException("Type mismatch for MsgTrackingStateDetailedDepA, expected 33, actual " + msg.type); } @Override @@ -148,7 +141,7 @@ protected void parse(Parser parser) throws SBPBinaryException { track_flags = parser.getU8(); nav_flags = parser.getU8(); pset_flags = parser.getU8(); - misc_flags = parser.getU8(); + misc_flags = parser.getU8(); } @Override @@ -173,7 +166,7 @@ protected void build(Builder builder) { builder.putU8(track_flags); builder.putU8(nav_flags); builder.putU8(pset_flags); - builder.putU8(misc_flags); + builder.putU8(misc_flags); } @Override diff --git a/java/src/com/swiftnav/sbp/tracking/TrackingChannelCorrelation.java b/java/src/com/swiftnav/sbp/tracking/TrackingChannelCorrelation.java index 25c5ba29d..2c06aa522 100644 --- a/java/src/com/swiftnav/sbp/tracking/TrackingChannelCorrelation.java +++ b/java/src/com/swiftnav/sbp/tracking/TrackingChannelCorrelation.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,27 +9,32 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class TrackingChannelCorrelation extends SBPStruct { - + /** In-phase correlation */ public int I; - + /** Quadrature correlation */ public int Q; + - public TrackingChannelCorrelation() {} + public TrackingChannelCorrelation () {} @Override public TrackingChannelCorrelation parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/tracking/TrackingChannelCorrelationDep.java b/java/src/com/swiftnav/sbp/tracking/TrackingChannelCorrelationDep.java index 3e5231b89..dffcc647d 100644 --- a/java/src/com/swiftnav/sbp/tracking/TrackingChannelCorrelationDep.java +++ b/java/src/com/swiftnav/sbp/tracking/TrackingChannelCorrelationDep.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,27 +9,32 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class TrackingChannelCorrelationDep extends SBPStruct { - + /** In-phase correlation */ public int I; - + /** Quadrature correlation */ public int Q; + - public TrackingChannelCorrelationDep() {} + public TrackingChannelCorrelationDep () {} @Override public TrackingChannelCorrelationDep parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/tracking/TrackingChannelState.java b/java/src/com/swiftnav/sbp/tracking/TrackingChannelState.java index 48c06df94..59a7a8cf8 100644 --- a/java/src/com/swiftnav/sbp/tracking/TrackingChannelState.java +++ b/java/src/com/swiftnav/sbp/tracking/TrackingChannelState.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,30 +9,35 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class TrackingChannelState extends SBPStruct { - + /** GNSS signal being tracked */ public GnssSignal sid; - + /** Frequency channel number (GLONASS only) */ public int fcn; - - /** Carrier-to-Noise density. Zero implies invalid cn0. */ + + /** Carrier-to-Noise density. Zero implies invalid cn0. */ public int cn0; + - public TrackingChannelState() {} + public TrackingChannelState () {} @Override public TrackingChannelState parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/tracking/TrackingChannelStateDepA.java b/java/src/com/swiftnav/sbp/tracking/TrackingChannelStateDepA.java index 84e88895c..9422bb0a8 100644 --- a/java/src/com/swiftnav/sbp/tracking/TrackingChannelStateDepA.java +++ b/java/src/com/swiftnav/sbp/tracking/TrackingChannelStateDepA.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,30 +9,35 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class TrackingChannelStateDepA extends SBPStruct { - + /** Status of tracking channel */ public int state; - + /** PRN-1 being tracked */ public int prn; - + /** Carrier-to-noise density */ public float cn0; + - public TrackingChannelStateDepA() {} + public TrackingChannelStateDepA () {} @Override public TrackingChannelStateDepA parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/tracking/TrackingChannelStateDepB.java b/java/src/com/swiftnav/sbp/tracking/TrackingChannelStateDepB.java index b7ad06ff1..0196a1d88 100644 --- a/java/src/com/swiftnav/sbp/tracking/TrackingChannelStateDepB.java +++ b/java/src/com/swiftnav/sbp/tracking/TrackingChannelStateDepB.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,30 +9,35 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.tracking; // This file was auto-generated from yaml/swiftnav/sbp/tracking.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPStruct; import com.swiftnav.sbp.gnss.*; + import org.json.JSONObject; +import org.json.JSONArray; public class TrackingChannelStateDepB extends SBPStruct { - + /** Status of tracking channel */ public int state; - + /** GNSS signal being tracked */ public GnssSignalDep sid; - + /** Carrier-to-noise density */ public float cn0; + - public TrackingChannelStateDepB() {} + public TrackingChannelStateDepB () {} @Override public TrackingChannelStateDepB parse(SBPMessage.Parser parser) throws SBPBinaryException { diff --git a/java/src/com/swiftnav/sbp/user/MsgUserData.java b/java/src/com/swiftnav/sbp/user/MsgUserData.java index 9877f44b6..531d62421 100644 --- a/java/src/com/swiftnav/sbp/user/MsgUserData.java +++ b/java/src/com/swiftnav/sbp/user/MsgUserData.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,56 +9,56 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.user; // This file was auto-generated from yaml/swiftnav/sbp/user.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import org.json.JSONArray; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; + -/** - * SBP class for message MSG_USER_DATA (0x0800). +/** SBP class for message MSG_USER_DATA (0x0800). * - *

You can have MSG_USER_DATA inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_USER_DATA inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

This message can contain any application specific user data up to a maximum length of 255 - * bytes per message. - */ + * This message can contain any application specific user data up to a maximum + * length of 255 bytes per message. */ + public class MsgUserData extends SBPMessage { public static final int TYPE = 0x0800; + /** User data payload */ public int[] contents; + - public MsgUserData(int sender) { - super(sender, TYPE); - } - - public MsgUserData() { - super(TYPE); - } - - public MsgUserData(SBPMessage msg) throws SBPBinaryException { + public MsgUserData (int sender) { super(sender, TYPE); } + public MsgUserData () { super(TYPE); } + public MsgUserData (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgUserData, expected 2048, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgUserData, expected 2048, actual " + msg.type); } @Override protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ - contents = parser.getArrayofU8(); + contents = parser.getArrayofU8(); } @Override protected void build(Builder builder) { - builder.putArrayofU8(contents); + builder.putArrayofU8(contents); } @Override diff --git a/java/src/com/swiftnav/sbp/vehicle/MsgOdometry.java b/java/src/com/swiftnav/sbp/vehicle/MsgOdometry.java index d556ec328..2f370b3a8 100644 --- a/java/src/com/swiftnav/sbp/vehicle/MsgOdometry.java +++ b/java/src/com/swiftnav/sbp/vehicle/MsgOdometry.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,59 +9,60 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.vehicle; // This file was auto-generated from yaml/swiftnav/sbp/vehicle.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_ODOMETRY (0x0903). + +/** SBP class for message MSG_ODOMETRY (0x0903). * - *

You can have MSG_ODOMETRY inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_ODOMETRY inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Message representing the x component of vehicle velocity in the user frame at the odometry - * reference point(s) specified by the user. The offset for the odometry reference point and the - * definition and origin of the user frame are defined through the device settings interface. There - * are 4 possible user-defined sources of this message which are labeled arbitrarily source 0 - * through 3. If using "processor time" time tags, the receiving end will expect either - * `MSG_GNSS_TIME_OFFSET` or `MSG_PPS_TIME` to sync incoming odometry data to GNSS time. Processor - * time shall roll over to zero after one week. - */ + * Message representing the x component of vehicle velocity in the user frame + * at the odometry reference point(s) specified by the user. The offset for + * the odometry reference point and the definition and origin of the user + * frame are defined through the device settings interface. There are 4 + * possible user-defined sources of this message which are labeled arbitrarily + * source 0 through 3. + * If using "processor time" time tags, the receiving end will expect either + * `MSG_GNSS_TIME_OFFSET` or `MSG_PPS_TIME` to sync incoming odometry data to + * GNSS time. Processor time shall roll over to zero after one week. */ + public class MsgOdometry extends SBPMessage { public static final int TYPE = 0x0903; - /** - * Time field representing either milliseconds in the GPS Week or local CPU time from the - * producing system in milliseconds. See the tow_source flag for the exact source of this - * timestamp. - */ + + /** Time field representing either milliseconds in the GPS Week or local + * CPU time from the producing system in milliseconds. See the + * tow_source flag for the exact source of this timestamp. */ public long tow; - + /** The signed forward component of vehicle velocity. */ public int velocity; - + /** Status flags */ public int flags; + - public MsgOdometry(int sender) { - super(sender, TYPE); - } - - public MsgOdometry() { - super(TYPE); - } - - public MsgOdometry(SBPMessage msg) throws SBPBinaryException { + public MsgOdometry (int sender) { super(sender, TYPE); } + public MsgOdometry () { super(TYPE); } + public MsgOdometry (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgOdometry, expected 2307, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgOdometry, expected 2307, actual " + msg.type); } @Override @@ -68,14 +70,14 @@ protected void parse(Parser parser) throws SBPBinaryException { /* Parse fields from binary */ tow = parser.getU32(); velocity = parser.getS32(); - flags = parser.getU8(); + flags = parser.getU8(); } @Override protected void build(Builder builder) { builder.putU32(tow); builder.putS32(velocity); - builder.putU8(flags); + builder.putU8(flags); } @Override diff --git a/java/src/com/swiftnav/sbp/vehicle/MsgWheeltick.java b/java/src/com/swiftnav/sbp/vehicle/MsgWheeltick.java index 10d60a66c..96390ddf1 100644 --- a/java/src/com/swiftnav/sbp/vehicle/MsgWheeltick.java +++ b/java/src/com/swiftnav/sbp/vehicle/MsgWheeltick.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2022 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,69 +9,69 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.vehicle; // This file was auto-generated from yaml/swiftnav/sbp/vehicle.yaml by generate.py. // Do not modify by hand! +import java.math.BigInteger; -import com.swiftnav.sbp.SBPBinaryException; import com.swiftnav.sbp.SBPMessage; -import java.math.BigInteger; +import com.swiftnav.sbp.SBPBinaryException; +import com.swiftnav.sbp.SBPStruct; + import org.json.JSONObject; +import org.json.JSONArray; -/** - * SBP class for message MSG_WHEELTICK (0x0904). + +/** SBP class for message MSG_WHEELTICK (0x0904). * - *

You can have MSG_WHEELTICK inherent its fields directly from an inherited SBP object, or - * construct it inline using a dict of its fields. + * You can have MSG_WHEELTICK inherent its fields directly from + * an inherited SBP object, or construct it inline using a dict of its + * fields. * - *

Message containing the accumulated distance travelled by a wheel located at an odometry - * reference point defined by the user. The offset for the odometry reference point and the - * definition and origin of the user frame are defined through the device settings interface. The - * source of this message is identified by the source field, which is an integer ranging from 0 to - * 255. The timestamp associated with this message should represent the time when the accumulated - * tick count reached the value given by the contents of this message as accurately as possible. If - * using "local CPU time" time tags, the receiving end will also expect either - * `MSG_GNSS_TIME_OFFSET` or `MSG_PPS_TIME` to sync incoming wheeltick data to GNSS time. Local CPU - * time shall roll over to zero after one week. - */ + * Message containing the accumulated distance travelled by a wheel located at + * an odometry reference point defined by the user. The offset for the + * odometry reference point and the definition and origin of the user frame + * are defined through the device settings interface. The source of this + * message is identified by the source field, which is an integer ranging from + * 0 to 255. The timestamp associated with this message should represent the + * time when the accumulated tick count reached the value given by the + * contents of this message as accurately as possible. If using "local CPU + * time" time tags, the receiving end will also expect either + * `MSG_GNSS_TIME_OFFSET` or `MSG_PPS_TIME` to sync incoming wheeltick data to + * GNSS time. + * Local CPU time shall roll over to zero after one week. */ + public class MsgWheeltick extends SBPMessage { public static final int TYPE = 0x0904; - /** - * Time field representing either microseconds since the last PPS, microseconds in the GPS Week - * or local CPU time from the producing system in microseconds. See the synch_type field for the - * exact meaning of this timestamp. - */ + + /** Time field representing either microseconds since the last PPS, + * microseconds in the GPS Week or local CPU time from the producing + * system in microseconds. See the synch_type field for the exact meaning + * of this timestamp. */ public BigInteger time; - + /** Field indicating the type of timestamp contained in the time field. */ public int flags; - + /** ID of the sensor producing this message */ public int source; - - /** - * Free-running counter of the accumulated distance for this sensor. The counter should be - * incrementing if travelling into one direction and decrementing when travelling in the - * opposite direction. - */ + + /** Free-running counter of the accumulated distance for this sensor. The + * counter should be incrementing if travelling into one direction and + * decrementing when travelling in the opposite direction. */ public int ticks; + - public MsgWheeltick(int sender) { - super(sender, TYPE); - } - - public MsgWheeltick() { - super(TYPE); - } - - public MsgWheeltick(SBPMessage msg) throws SBPBinaryException { + public MsgWheeltick (int sender) { super(sender, TYPE); } + public MsgWheeltick () { super(TYPE); } + public MsgWheeltick (SBPMessage msg) throws SBPBinaryException { super(msg); if (msg.type != TYPE) - throw new SBPBinaryException( - "Type mismatch for MsgWheeltick, expected 2308, actual " + msg.type); + throw new SBPBinaryException("Type mismatch for MsgWheeltick, expected 2308, actual " + msg.type); } @Override @@ -79,7 +80,7 @@ protected void parse(Parser parser) throws SBPBinaryException { time = parser.getU64(); flags = parser.getU8(); source = parser.getU8(); - ticks = parser.getS32(); + ticks = parser.getS32(); } @Override @@ -87,7 +88,7 @@ protected void build(Builder builder) { builder.putU64(time); builder.putU8(flags); builder.putU8(source); - builder.putS32(ticks); + builder.putS32(ticks); } @Override diff --git a/java/test/auto_check_sbp_acquisition_MsgAcqResultDepATest.java b/java/test/auto_check_sbp_acquisition_MsgAcqResultDepATest.java index a45d02d6d..d5e66b9a1 100644 --- a/java/test/auto_check_sbp_acquisition_MsgAcqResultDepATest.java +++ b/java/test/auto_check_sbp_acquisition_MsgAcqResultDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/acquisition/test_MsgAcqResultDepA.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/acquisition/test_MsgAcqResultDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.acquisition.MsgAcqResultDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_acquisition_MsgAcqResultDepATest { @@ -30,24 +34,9 @@ public class auto_check_sbp_acquisition_MsgAcqResultDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 0, - (byte) 104, - (byte) 65, - (byte) 0, - (byte) 192, - (byte) 53, - (byte) 68, - (byte) 198, - (byte) 199, - (byte) 0, - (byte) 70, - (byte) 8, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x15, payload); - MsgAcqResultDepA msg = new MsgAcqResultDepA(sbp); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)104,(byte)65,(byte)0,(byte)192,(byte)53,(byte)68,(byte)198,(byte)199,(byte)0,(byte)70,(byte)8, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x15, payload ); + MsgAcqResultDepA msg = new MsgAcqResultDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -55,8 +44,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 7.27000000000000000e+02, DELTA); value = msg.prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.prn + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.prn + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -71,24 +59,9 @@ public void test1() throws Throwable { public void test2() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepATest.test2"); - byte[] payload = - new byte[] { - (byte) 205, - (byte) 204, - (byte) 116, - (byte) 65, - (byte) 0, - (byte) 192, - (byte) 179, - (byte) 67, - (byte) 33, - (byte) 81, - (byte) 59, - (byte) 68, - (byte) 9, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x15, payload); - MsgAcqResultDepA msg = new MsgAcqResultDepA(sbp); + byte[] payload = new byte[] {(byte)205,(byte)204,(byte)116,(byte)65,(byte)0,(byte)192,(byte)179,(byte)67,(byte)33,(byte)81,(byte)59,(byte)68,(byte)9, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x15, payload ); + MsgAcqResultDepA msg = new MsgAcqResultDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -96,8 +69,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 3.59500000000000000e+02, DELTA); value = msg.prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.prn + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.prn + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -112,24 +84,9 @@ public void test2() throws Throwable { public void test3() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepATest.test3"); - byte[] payload = - new byte[] { - (byte) 205, - (byte) 204, - (byte) 144, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 34, - (byte) 66, - (byte) 57, - (byte) 237, - (byte) 202, - (byte) 197, - (byte) 11, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x15, payload); - MsgAcqResultDepA msg = new MsgAcqResultDepA(sbp); + byte[] payload = new byte[] {(byte)205,(byte)204,(byte)144,(byte)65,(byte)0,(byte)0,(byte)34,(byte)66,(byte)57,(byte)237,(byte)202,(byte)197,(byte)11, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x15, payload ); + MsgAcqResultDepA msg = new MsgAcqResultDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -137,8 +94,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 4.05000000000000000e+01, DELTA); value = msg.prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.prn + "' != '" + 11 + "'", value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.prn + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -153,24 +109,9 @@ public void test3() throws Throwable { public void test4() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepATest.test4"); - byte[] payload = - new byte[] { - (byte) 205, - (byte) 204, - (byte) 116, - (byte) 65, - (byte) 0, - (byte) 32, - (byte) 9, - (byte) 68, - (byte) 129, - (byte) 193, - (byte) 121, - (byte) 196, - (byte) 12, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x15, payload); - MsgAcqResultDepA msg = new MsgAcqResultDepA(sbp); + byte[] payload = new byte[] {(byte)205,(byte)204,(byte)116,(byte)65,(byte)0,(byte)32,(byte)9,(byte)68,(byte)129,(byte)193,(byte)121,(byte)196,(byte)12, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x15, payload ); + MsgAcqResultDepA msg = new MsgAcqResultDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -178,8 +119,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 5.48500000000000000e+02, DELTA); value = msg.prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.prn + "' != '" + 12 + "'", value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.prn + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -194,24 +134,9 @@ public void test4() throws Throwable { public void test5() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepATest.test5"); - byte[] payload = - new byte[] { - (byte) 205, - (byte) 204, - (byte) 116, - (byte) 65, - (byte) 0, - (byte) 32, - (byte) 67, - (byte) 68, - (byte) 228, - (byte) 74, - (byte) 148, - (byte) 69, - (byte) 14, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x15, payload); - MsgAcqResultDepA msg = new MsgAcqResultDepA(sbp); + byte[] payload = new byte[] {(byte)205,(byte)204,(byte)116,(byte)65,(byte)0,(byte)32,(byte)67,(byte)68,(byte)228,(byte)74,(byte)148,(byte)69,(byte)14, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x15, payload ); + MsgAcqResultDepA msg = new MsgAcqResultDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -219,8 +144,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 7.80500000000000000e+02, DELTA); value = msg.prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.prn + "' != '" + 14 + "'", value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.prn + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -235,24 +159,9 @@ public void test5() throws Throwable { public void test6() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepATest.test6"); - byte[] payload = - new byte[] { - (byte) 228, - (byte) 56, - (byte) 35, - (byte) 67, - (byte) 0, - (byte) 32, - (byte) 18, - (byte) 68, - (byte) 129, - (byte) 193, - (byte) 249, - (byte) 195, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x15, payload); - MsgAcqResultDepA msg = new MsgAcqResultDepA(sbp); + byte[] payload = new byte[] {(byte)228,(byte)56,(byte)35,(byte)67,(byte)0,(byte)32,(byte)18,(byte)68,(byte)129,(byte)193,(byte)249,(byte)195,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x15, payload ); + MsgAcqResultDepA msg = new MsgAcqResultDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -260,8 +169,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 5.84500000000000000e+02, DELTA); value = msg.prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; diff --git a/java/test/auto_check_sbp_acquisition_MsgAcqResultDepBTest.java b/java/test/auto_check_sbp_acquisition_MsgAcqResultDepBTest.java index caf564412..d5ffc9810 100644 --- a/java/test/auto_check_sbp_acquisition_MsgAcqResultDepBTest.java +++ b/java/test/auto_check_sbp_acquisition_MsgAcqResultDepBTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/acquisition/test_MsgAcqResultDepB.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/acquisition/test_MsgAcqResultDepB.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.acquisition.MsgAcqResultDepB; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_acquisition_MsgAcqResultDepBTest { @@ -30,14 +34,9 @@ public class auto_check_sbp_acquisition_MsgAcqResultDepBTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepBTest.test1"); - byte[] payload = - new byte[] { - (byte) 137, (byte) 167, (byte) 18, (byte) 66, (byte) 0, (byte) 0, (byte) 161, - (byte) 67, (byte) 240, (byte) 24, (byte) 156, (byte) 69, (byte) 9, (byte) 0, - (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x14, payload); - MsgAcqResultDepB msg = new MsgAcqResultDepB(sbp); + byte[] payload = new byte[] {(byte)137,(byte)167,(byte)18,(byte)66,(byte)0,(byte)0,(byte)161,(byte)67,(byte)240,(byte)24,(byte)156,(byte)69,(byte)9,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x14, payload ); + MsgAcqResultDepB msg = new MsgAcqResultDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -45,8 +44,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 3.22000000000000000e+02, DELTA); value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -54,9 +52,7 @@ public void test1() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -64,8 +60,7 @@ public void test1() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -80,14 +75,9 @@ public void test1() throws Throwable { public void test2() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepBTest.test2"); - byte[] payload = - new byte[] { - (byte) 206, (byte) 172, (byte) 16, (byte) 66, (byte) 0, (byte) 192, (byte) 82, - (byte) 68, (byte) 198, (byte) 199, (byte) 0, (byte) 198, (byte) 3, (byte) 0, - (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x14, payload); - MsgAcqResultDepB msg = new MsgAcqResultDepB(sbp); + byte[] payload = new byte[] {(byte)206,(byte)172,(byte)16,(byte)66,(byte)0,(byte)192,(byte)82,(byte)68,(byte)198,(byte)199,(byte)0,(byte)198,(byte)3,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x14, payload ); + MsgAcqResultDepB msg = new MsgAcqResultDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -95,8 +85,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 8.43000000000000000e+02, DELTA); value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -104,9 +93,7 @@ public void test2() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -114,8 +101,7 @@ public void test2() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -130,14 +116,9 @@ public void test2() throws Throwable { public void test3() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepBTest.test3"); - byte[] payload = - new byte[] { - (byte) 228, (byte) 27, (byte) 15, (byte) 66, (byte) 0, (byte) 128, (byte) 70, - (byte) 68, (byte) 228, (byte) 74, (byte) 148, (byte) 69, (byte) 18, (byte) 0, - (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x14, payload); - MsgAcqResultDepB msg = new MsgAcqResultDepB(sbp); + byte[] payload = new byte[] {(byte)228,(byte)27,(byte)15,(byte)66,(byte)0,(byte)128,(byte)70,(byte)68,(byte)228,(byte)74,(byte)148,(byte)69,(byte)18,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x14, payload ); + MsgAcqResultDepB msg = new MsgAcqResultDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -145,8 +126,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 7.94000000000000000e+02, DELTA); value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -154,9 +134,7 @@ public void test3() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -164,8 +142,7 @@ public void test3() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 18 + "'", value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -180,14 +157,9 @@ public void test3() throws Throwable { public void test4() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepBTest.test4"); - byte[] payload = - new byte[] { - (byte) 46, (byte) 199, (byte) 14, (byte) 66, (byte) 0, (byte) 64, (byte) 129, - (byte) 67, (byte) 240, (byte) 24, (byte) 28, (byte) 69, (byte) 17, (byte) 0, - (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x14, payload); - MsgAcqResultDepB msg = new MsgAcqResultDepB(sbp); + byte[] payload = new byte[] {(byte)46,(byte)199,(byte)14,(byte)66,(byte)0,(byte)64,(byte)129,(byte)67,(byte)240,(byte)24,(byte)28,(byte)69,(byte)17,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x14, payload ); + MsgAcqResultDepB msg = new MsgAcqResultDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -195,8 +167,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 2.58500000000000000e+02, DELTA); value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -204,9 +175,7 @@ public void test4() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -214,8 +183,7 @@ public void test4() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 17 + "'", value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -230,14 +198,9 @@ public void test4() throws Throwable { public void test5() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepBTest.test5"); - byte[] payload = - new byte[] { - (byte) 194, (byte) 24, (byte) 14, (byte) 66, (byte) 0, (byte) 128, (byte) 2, - (byte) 68, (byte) 129, (byte) 193, (byte) 249, (byte) 195, (byte) 5, (byte) 0, - (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x14, payload); - MsgAcqResultDepB msg = new MsgAcqResultDepB(sbp); + byte[] payload = new byte[] {(byte)194,(byte)24,(byte)14,(byte)66,(byte)0,(byte)128,(byte)2,(byte)68,(byte)129,(byte)193,(byte)249,(byte)195,(byte)5,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x14, payload ); + MsgAcqResultDepB msg = new MsgAcqResultDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -245,8 +208,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 5.22000000000000000e+02, DELTA); value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -254,9 +216,7 @@ public void test5() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -264,8 +224,7 @@ public void test5() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; diff --git a/java/test/auto_check_sbp_acquisition_MsgAcqResultDepCTest.java b/java/test/auto_check_sbp_acquisition_MsgAcqResultDepCTest.java index 667df5e8b..6ef3501d4 100644 --- a/java/test/auto_check_sbp_acquisition_MsgAcqResultDepCTest.java +++ b/java/test/auto_check_sbp_acquisition_MsgAcqResultDepCTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/acquisition/test_MsgAcqResultDepC.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/acquisition/test_MsgAcqResultDepC.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.acquisition.MsgAcqResultDepC; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_acquisition_MsgAcqResultDepCTest { @@ -30,14 +34,9 @@ public class auto_check_sbp_acquisition_MsgAcqResultDepCTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepCTest.test1"); - byte[] payload = - new byte[] { - (byte) 72, (byte) 9, (byte) 34, (byte) 66, (byte) 155, (byte) 152, (byte) 228, - (byte) 67, (byte) 28, (byte) 34, (byte) 221, (byte) 68, (byte) 10, (byte) 0, - (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xc28, 0x1f, payload); - MsgAcqResultDepC msg = new MsgAcqResultDepC(sbp); + byte[] payload = new byte[] {(byte)72,(byte)9,(byte)34,(byte)66,(byte)155,(byte)152,(byte)228,(byte)67,(byte)28,(byte)34,(byte)221,(byte)68,(byte)10,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xc28, 0x1f, payload ); + MsgAcqResultDepC msg = new MsgAcqResultDepC( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -46,8 +45,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 4.57192230224609375e+02, DELTA); value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -55,9 +53,7 @@ public void test1() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -65,8 +61,7 @@ public void test1() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 10 + "'", value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -80,14 +75,9 @@ public void test1() throws Throwable { public void test2() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepCTest.test2"); - byte[] payload = - new byte[] { - (byte) 132, (byte) 250, (byte) 45, (byte) 66, (byte) 207, (byte) 93, (byte) 88, - (byte) 68, (byte) 68, (byte) 185, (byte) 252, (byte) 195, (byte) 6, (byte) 0, - (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xc28, 0x1f, payload); - MsgAcqResultDepC msg = new MsgAcqResultDepC(sbp); + byte[] payload = new byte[] {(byte)132,(byte)250,(byte)45,(byte)66,(byte)207,(byte)93,(byte)88,(byte)68,(byte)68,(byte)185,(byte)252,(byte)195,(byte)6,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xc28, 0x1f, payload ); + MsgAcqResultDepC msg = new MsgAcqResultDepC( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -96,8 +86,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 8.65465759277343750e+02, DELTA); value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -105,9 +94,7 @@ public void test2() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -115,8 +102,7 @@ public void test2() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -130,14 +116,9 @@ public void test2() throws Throwable { public void test3() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepCTest.test3"); - byte[] payload = - new byte[] { - (byte) 163, (byte) 223, (byte) 24, (byte) 66, (byte) 64, (byte) 91, (byte) 102, - (byte) 67, (byte) 202, (byte) 243, (byte) 157, (byte) 196, (byte) 13, (byte) 0, - (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xc28, 0x1f, payload); - MsgAcqResultDepC msg = new MsgAcqResultDepC(sbp); + byte[] payload = new byte[] {(byte)163,(byte)223,(byte)24,(byte)66,(byte)64,(byte)91,(byte)102,(byte)67,(byte)202,(byte)243,(byte)157,(byte)196,(byte)13,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xc28, 0x1f, payload ); + MsgAcqResultDepC msg = new MsgAcqResultDepC( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -146,8 +127,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 2.30356445312500000e+02, DELTA); value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -155,9 +135,7 @@ public void test3() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -165,8 +143,7 @@ public void test3() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 13 + "'", value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -180,14 +157,9 @@ public void test3() throws Throwable { public void test4() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepCTest.test4"); - byte[] payload = - new byte[] { - (byte) 129, (byte) 65, (byte) 21, (byte) 66, (byte) 224, (byte) 214, (byte) 124, - (byte) 67, (byte) 243, (byte) 138, (byte) 61, (byte) 69, (byte) 1, (byte) 0, - (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xc28, 0x1f, payload); - MsgAcqResultDepC msg = new MsgAcqResultDepC(sbp); + byte[] payload = new byte[] {(byte)129,(byte)65,(byte)21,(byte)66,(byte)224,(byte)214,(byte)124,(byte)67,(byte)243,(byte)138,(byte)61,(byte)69,(byte)1,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xc28, 0x1f, payload ); + MsgAcqResultDepC msg = new MsgAcqResultDepC( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -196,8 +168,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 2.52839355468750000e+02, DELTA); value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -205,9 +176,7 @@ public void test4() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -215,8 +184,7 @@ public void test4() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -230,14 +198,9 @@ public void test4() throws Throwable { public void test5() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultDepCTest.test5"); - byte[] payload = - new byte[] { - (byte) 126, (byte) 35, (byte) 62, (byte) 66, (byte) 226, (byte) 37, (byte) 102, - (byte) 68, (byte) 202, (byte) 243, (byte) 29, (byte) 69, (byte) 27, (byte) 0, - (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xc28, 0x1f, payload); - MsgAcqResultDepC msg = new MsgAcqResultDepC(sbp); + byte[] payload = new byte[] {(byte)126,(byte)35,(byte)62,(byte)66,(byte)226,(byte)37,(byte)102,(byte)68,(byte)202,(byte)243,(byte)29,(byte)69,(byte)27,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xc28, 0x1f, payload ); + MsgAcqResultDepC msg = new MsgAcqResultDepC( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -246,8 +209,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 9.20591918945312500e+02, DELTA); value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -255,9 +217,7 @@ public void test5() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -265,8 +225,7 @@ public void test5() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 27 + "'", value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; diff --git a/java/test/auto_check_sbp_acquisition_MsgAcqResultTest.java b/java/test/auto_check_sbp_acquisition_MsgAcqResultTest.java index 508536215..bf754e455 100644 --- a/java/test/auto_check_sbp_acquisition_MsgAcqResultTest.java +++ b/java/test/auto_check_sbp_acquisition_MsgAcqResultTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/acquisition/test_MsgAcqResult.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/acquisition/test_MsgAcqResult.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.acquisition.MsgAcqResult; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_acquisition_MsgAcqResultTest { @@ -27,14 +32,11 @@ public class auto_check_sbp_acquisition_MsgAcqResultTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultTest.test1"); - byte[] payload = - new byte[] { - (byte) 0, (byte) 0, (byte) 104, (byte) 65, (byte) 102, (byte) 102, (byte) 144, - (byte) 66, (byte) 205, (byte) 196, (byte) 0, (byte) 70, (byte) 8, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0x2f, payload); - MsgAcqResult msg = new MsgAcqResult(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqResultTest.test1"); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)104,(byte)65,(byte)102,(byte)102,(byte)144,(byte)66,(byte)205,(byte)196,(byte)0,(byte)70,(byte)8,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0x2f, payload ); + MsgAcqResult msg = new MsgAcqResult( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -43,8 +45,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.cp, 7.21999969482421875e+01, DELTA); value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -52,8 +53,7 @@ public void test1() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; diff --git a/java/test/auto_check_sbp_acquisition_MsgAcqSvProfileDepTest.java b/java/test/auto_check_sbp_acquisition_MsgAcqSvProfileDepTest.java index 1079d6d45..911e19915 100644 --- a/java/test/auto_check_sbp_acquisition_MsgAcqSvProfileDepTest.java +++ b/java/test/auto_check_sbp_acquisition_MsgAcqSvProfileDepTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/acquisition/test_MsgAcqSvProfileDep.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/acquisition/test_MsgAcqSvProfileDep.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.acquisition.MsgAcqSvProfileDep; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_acquisition_MsgAcqSvProfileDepTest { @@ -30,34 +34,15 @@ public class auto_check_sbp_acquisition_MsgAcqSvProfileDepTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqSvProfileDepTest.test1"); - byte[] payload = - new byte[] { - (byte) 67, (byte) 103, (byte) 151, (byte) 0, (byte) 12, (byte) 22, (byte) 0, - (byte) 0, (byte) 0, (byte) 187, (byte) 0, (byte) 91, (byte) 0, (byte) 0, - (byte) 0, (byte) 75, (byte) 0, (byte) 0, (byte) 0, (byte) 132, (byte) 0, - (byte) 0, (byte) 0, (byte) 36, (byte) 0, (byte) 0, (byte) 0, (byte) 60, - (byte) 0, (byte) 0, (byte) 0, (byte) 241, (byte) 0, (byte) 0, (byte) 0, - (byte) 238, (byte) 38, (byte) 111, (byte) 0, (byte) 179, (byte) 23, (byte) 0, - (byte) 1, (byte) 0, (byte) 176, (byte) 0, (byte) 166, (byte) 0, (byte) 0, - (byte) 0, (byte) 234, (byte) 0, (byte) 0, (byte) 0, (byte) 155, (byte) 0, - (byte) 0, (byte) 0, (byte) 24, (byte) 0, (byte) 0, (byte) 0, (byte) 212, - (byte) 0, (byte) 0, (byte) 0, (byte) 247, (byte) 0, (byte) 0, (byte) 0, - (byte) 142, (byte) 213, (byte) 68, (byte) 0, (byte) 53, (byte) 24, (byte) 0, - (byte) 0, (byte) 0, (byte) 52, (byte) 0, (byte) 49, (byte) 0, (byte) 0, - (byte) 0, (byte) 245, (byte) 0, (byte) 0, (byte) 0, (byte) 76, (byte) 0, - (byte) 0, (byte) 0, (byte) 248, (byte) 0, (byte) 0, (byte) 0, (byte) 212, - (byte) 0, (byte) 0, (byte) 0, (byte) 101, (byte) 0, (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0x1e, payload); - MsgAcqSvProfileDep msg = new MsgAcqSvProfileDep(sbp); + byte[] payload = new byte[] {(byte)67,(byte)103,(byte)151,(byte)0,(byte)12,(byte)22,(byte)0,(byte)0,(byte)0,(byte)187,(byte)0,(byte)91,(byte)0,(byte)0,(byte)0,(byte)75,(byte)0,(byte)0,(byte)0,(byte)132,(byte)0,(byte)0,(byte)0,(byte)36,(byte)0,(byte)0,(byte)0,(byte)60,(byte)0,(byte)0,(byte)0,(byte)241,(byte)0,(byte)0,(byte)0,(byte)238,(byte)38,(byte)111,(byte)0,(byte)179,(byte)23,(byte)0,(byte)1,(byte)0,(byte)176,(byte)0,(byte)166,(byte)0,(byte)0,(byte)0,(byte)234,(byte)0,(byte)0,(byte)0,(byte)155,(byte)0,(byte)0,(byte)0,(byte)24,(byte)0,(byte)0,(byte)0,(byte)212,(byte)0,(byte)0,(byte)0,(byte)247,(byte)0,(byte)0,(byte)0,(byte)142,(byte)213,(byte)68,(byte)0,(byte)53,(byte)24,(byte)0,(byte)0,(byte)0,(byte)52,(byte)0,(byte)49,(byte)0,(byte)0,(byte)0,(byte)245,(byte)0,(byte)0,(byte)0,(byte)76,(byte)0,(byte)0,(byte)0,(byte)248,(byte)0,(byte)0,(byte)0,(byte)212,(byte)0,(byte)0,(byte)0,(byte)101,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0x1e, payload ); + MsgAcqSvProfileDep msg = new MsgAcqSvProfileDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.acq_sv_profile[0].bin_width; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].bin_width + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].bin_width + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -65,9 +50,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].cf; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].cf + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].cf + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -75,9 +58,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].cf_max; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].cf_max + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].cf_max + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -85,9 +66,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].cf_min; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].cf_min + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].cf_min + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -95,9 +74,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].cn0 + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].cn0 + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -105,9 +82,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].cp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].cp + "' != '" + 241 + "'", - value.equals(BigInteger.valueOf(241L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].cp + "' != '" + 241 + "'", value.equals(BigInteger.valueOf( 241L ) ) ); } else { value = value.longValue(); expected = 241L; @@ -115,9 +90,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].int_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].int_time + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].int_time + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -125,9 +98,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].job_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].job_type + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].job_type + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -135,9 +106,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -145,9 +114,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -155,9 +122,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].sid.sat + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].sid.sat + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -165,9 +130,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].status; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].status + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].status + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -175,9 +138,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].time_spent; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].time_spent + "' != '" + 75 + "'", - value.equals(BigInteger.valueOf(75L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].time_spent + "' != '" + 75 + "'", value.equals(BigInteger.valueOf( 75L ) ) ); } else { value = value.longValue(); expected = 75L; @@ -185,9 +146,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].timestamp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].timestamp + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].timestamp + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -195,9 +154,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].bin_width; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].bin_width + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].bin_width + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -205,9 +162,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].cf; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].cf + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].cf + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -215,9 +170,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].cf_max; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].cf_max + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].cf_max + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -225,9 +178,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].cf_min; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].cf_min + "' != '" + 155 + "'", - value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].cf_min + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -235,9 +186,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].cn0 + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].cn0 + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -245,9 +194,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].cp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].cp + "' != '" + 247 + "'", - value.equals(BigInteger.valueOf(247L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].cp + "' != '" + 247 + "'", value.equals(BigInteger.valueOf( 247L ) ) ); } else { value = value.longValue(); expected = 247L; @@ -255,9 +202,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].int_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].int_time + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].int_time + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -265,9 +210,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].job_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].job_type + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].job_type + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -275,9 +218,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].sid.code + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].sid.code + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -285,9 +226,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -295,9 +234,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].sid.sat + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].sid.sat + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -305,9 +242,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].status; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].status + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].status + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -315,9 +250,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].time_spent; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].time_spent + "' != '" + 234 + "'", - value.equals(BigInteger.valueOf(234L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].time_spent + "' != '" + 234 + "'", value.equals(BigInteger.valueOf( 234L ) ) ); } else { value = value.longValue(); expected = 234L; @@ -325,9 +258,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].timestamp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].timestamp + "' != '" + 166 + "'", - value.equals(BigInteger.valueOf(166L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].timestamp + "' != '" + 166 + "'", value.equals(BigInteger.valueOf( 166L ) ) ); } else { value = value.longValue(); expected = 166L; @@ -335,9 +266,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].bin_width; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].bin_width + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].bin_width + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -345,9 +274,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].cf; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].cf + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].cf + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -355,9 +282,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].cf_max; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].cf_max + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].cf_max + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -365,9 +290,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].cf_min; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].cf_min + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].cf_min + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -375,9 +298,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].cn0 + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].cn0 + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -385,9 +306,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].cp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].cp + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].cp + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -395,9 +314,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].int_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].int_time + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].int_time + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -405,9 +322,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].job_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].job_type + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].job_type + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -415,9 +330,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -425,9 +338,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -435,9 +346,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].sid.sat + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].sid.sat + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -445,9 +354,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].status; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].status + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].status + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -455,9 +362,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].time_spent; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].time_spent + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].time_spent + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -465,9 +370,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].timestamp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].timestamp + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].timestamp + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; diff --git a/java/test/auto_check_sbp_acquisition_MsgAcqSvProfileTest.java b/java/test/auto_check_sbp_acquisition_MsgAcqSvProfileTest.java index 98814ef39..3657fad8b 100644 --- a/java/test/auto_check_sbp_acquisition_MsgAcqSvProfileTest.java +++ b/java/test/auto_check_sbp_acquisition_MsgAcqSvProfileTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/acquisition/test_MsgAcqSvProfile.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/acquisition/test_MsgAcqSvProfile.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.acquisition.MsgAcqSvProfile; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_acquisition_MsgAcqSvProfileTest { @@ -30,34 +34,15 @@ public class auto_check_sbp_acquisition_MsgAcqSvProfileTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_acquisition_MsgAcqSvProfileTest.test1"); - byte[] payload = - new byte[] { - (byte) 7, (byte) 13, (byte) 38, (byte) 0, (byte) 97, (byte) 22, (byte) 0, - (byte) 174, (byte) 0, (byte) 52, (byte) 0, (byte) 0, (byte) 0, (byte) 49, - (byte) 0, (byte) 0, (byte) 0, (byte) 61, (byte) 0, (byte) 0, (byte) 0, - (byte) 147, (byte) 0, (byte) 0, (byte) 0, (byte) 47, (byte) 0, (byte) 0, - (byte) 0, (byte) 140, (byte) 0, (byte) 0, (byte) 0, (byte) 166, (byte) 210, - (byte) 59, (byte) 0, (byte) 253, (byte) 23, (byte) 1, (byte) 121, (byte) 0, - (byte) 190, (byte) 0, (byte) 0, (byte) 0, (byte) 175, (byte) 0, (byte) 0, - (byte) 0, (byte) 175, (byte) 0, (byte) 0, (byte) 0, (byte) 142, (byte) 0, - (byte) 0, (byte) 0, (byte) 237, (byte) 0, (byte) 0, (byte) 0, (byte) 12, - (byte) 0, (byte) 0, (byte) 0, (byte) 126, (byte) 88, (byte) 21, (byte) 0, - (byte) 153, (byte) 24, (byte) 0, (byte) 8, (byte) 0, (byte) 130, (byte) 0, - (byte) 0, (byte) 0, (byte) 172, (byte) 0, (byte) 0, (byte) 0, (byte) 91, - (byte) 0, (byte) 0, (byte) 0, (byte) 191, (byte) 0, (byte) 0, (byte) 0, - (byte) 84, (byte) 0, (byte) 0, (byte) 0, (byte) 82, (byte) 0, (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0x2e, payload); - MsgAcqSvProfile msg = new MsgAcqSvProfile(sbp); + byte[] payload = new byte[] {(byte)7,(byte)13,(byte)38,(byte)0,(byte)97,(byte)22,(byte)0,(byte)174,(byte)0,(byte)52,(byte)0,(byte)0,(byte)0,(byte)49,(byte)0,(byte)0,(byte)0,(byte)61,(byte)0,(byte)0,(byte)0,(byte)147,(byte)0,(byte)0,(byte)0,(byte)47,(byte)0,(byte)0,(byte)0,(byte)140,(byte)0,(byte)0,(byte)0,(byte)166,(byte)210,(byte)59,(byte)0,(byte)253,(byte)23,(byte)1,(byte)121,(byte)0,(byte)190,(byte)0,(byte)0,(byte)0,(byte)175,(byte)0,(byte)0,(byte)0,(byte)175,(byte)0,(byte)0,(byte)0,(byte)142,(byte)0,(byte)0,(byte)0,(byte)237,(byte)0,(byte)0,(byte)0,(byte)12,(byte)0,(byte)0,(byte)0,(byte)126,(byte)88,(byte)21,(byte)0,(byte)153,(byte)24,(byte)0,(byte)8,(byte)0,(byte)130,(byte)0,(byte)0,(byte)0,(byte)172,(byte)0,(byte)0,(byte)0,(byte)91,(byte)0,(byte)0,(byte)0,(byte)191,(byte)0,(byte)0,(byte)0,(byte)84,(byte)0,(byte)0,(byte)0,(byte)82,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0x2e, payload ); + MsgAcqSvProfile msg = new MsgAcqSvProfile( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.acq_sv_profile[0].bin_width; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].bin_width + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].bin_width + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -65,9 +50,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].cf; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].cf + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].cf + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -75,9 +58,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].cf_max; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].cf_max + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].cf_max + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -85,9 +66,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].cf_min; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].cf_min + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].cf_min + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -95,9 +74,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].cn0 + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].cn0 + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -105,9 +82,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].cp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].cp + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].cp + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -115,9 +90,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].int_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].int_time + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].int_time + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -125,9 +98,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].job_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].job_type + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].job_type + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -135,9 +106,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -145,9 +114,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].sid.sat + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].sid.sat + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -155,9 +122,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].status; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].status + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].status + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -165,9 +130,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].time_spent; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].time_spent + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].time_spent + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -175,9 +138,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[0].timestamp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[0].timestamp + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[0].timestamp + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -185,9 +146,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].bin_width; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].bin_width + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].bin_width + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -195,9 +154,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].cf; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].cf + "' != '" + 237 + "'", - value.equals(BigInteger.valueOf(237L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].cf + "' != '" + 237 + "'", value.equals(BigInteger.valueOf( 237L ) ) ); } else { value = value.longValue(); expected = 237L; @@ -205,9 +162,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].cf_max; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].cf_max + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].cf_max + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -215,9 +170,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].cf_min; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].cf_min + "' != '" + 175 + "'", - value.equals(BigInteger.valueOf(175L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].cf_min + "' != '" + 175 + "'", value.equals(BigInteger.valueOf( 175L ) ) ); } else { value = value.longValue(); expected = 175L; @@ -225,9 +178,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].cn0 + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].cn0 + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -235,9 +186,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].cp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].cp + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].cp + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -245,9 +194,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].int_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].int_time + "' != '" + 253 + "'", - value.equals(BigInteger.valueOf(253L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].int_time + "' != '" + 253 + "'", value.equals(BigInteger.valueOf( 253L ) ) ); } else { value = value.longValue(); expected = 253L; @@ -255,9 +202,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].job_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].job_type + "' != '" + 166 + "'", - value.equals(BigInteger.valueOf(166L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].job_type + "' != '" + 166 + "'", value.equals(BigInteger.valueOf( 166L ) ) ); } else { value = value.longValue(); expected = 166L; @@ -265,9 +210,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].sid.code + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].sid.code + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -275,9 +218,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].sid.sat + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].sid.sat + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -285,9 +226,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].status; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].status + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].status + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -295,9 +234,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].time_spent; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].time_spent + "' != '" + 175 + "'", - value.equals(BigInteger.valueOf(175L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].time_spent + "' != '" + 175 + "'", value.equals(BigInteger.valueOf( 175L ) ) ); } else { value = value.longValue(); expected = 175L; @@ -305,9 +242,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[1].timestamp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[1].timestamp + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[1].timestamp + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -315,9 +250,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].bin_width; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].bin_width + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].bin_width + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -325,9 +258,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].cf; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].cf + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].cf + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -335,9 +266,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].cf_max; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].cf_max + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].cf_max + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -345,9 +274,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].cf_min; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].cf_min + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].cf_min + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -355,9 +282,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].cn0 + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].cn0 + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -365,9 +290,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].cp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].cp + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].cp + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -375,9 +298,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].int_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].int_time + "' != '" + 153 + "'", - value.equals(BigInteger.valueOf(153L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].int_time + "' != '" + 153 + "'", value.equals(BigInteger.valueOf( 153L ) ) ); } else { value = value.longValue(); expected = 153L; @@ -385,9 +306,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].job_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].job_type + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].job_type + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -395,9 +314,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -405,9 +322,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].sid.sat + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].sid.sat + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -415,9 +330,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].status; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].status + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].status + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -425,9 +338,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].time_spent; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].time_spent + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].time_spent + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -435,9 +346,7 @@ public void test1() throws Throwable { } value = msg.acq_sv_profile[2].timestamp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acq_sv_profile[2].timestamp + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.acq_sv_profile[2].timestamp + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; diff --git a/java/test/auto_check_sbp_bootload_MsgBootloaderHandshakeReqTest.java b/java/test/auto_check_sbp_bootload_MsgBootloaderHandshakeReqTest.java index 74c78834f..365902f2e 100644 --- a/java/test/auto_check_sbp_bootload_MsgBootloaderHandshakeReqTest.java +++ b/java/test/auto_check_sbp_bootload_MsgBootloaderHandshakeReqTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/bootload/test_MsgBootloaderHandshakeReq.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/bootload/test_MsgBootloaderHandshakeReq.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; +import org.junit.Test; + +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.bootload.MsgBootloaderHandshakeReq; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_bootload_MsgBootloaderHandshakeReqTest { @@ -28,11 +33,10 @@ public class auto_check_sbp_bootload_MsgBootloaderHandshakeReqTest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_bootload_MsgBootloaderHandshakeReqTest.test1"); - byte[] payload = new byte[] {}; - SBPMessage sbp = new SBPMessage(0xf788, 0xb3, payload); - MsgBootloaderHandshakeReq msg = new MsgBootloaderHandshakeReq(sbp); + System.out.format("%n%s%n", "auto_check_sbp_bootload_MsgBootloaderHandshakeReqTest.test1"); + byte[] payload = new byte[] { }; + SBPMessage sbp = new SBPMessage( 0xf788, 0xb3, payload ); + MsgBootloaderHandshakeReq msg = new MsgBootloaderHandshakeReq( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; diff --git a/java/test/auto_check_sbp_bootload_MsgBootloaderHandshakeRespTest.java b/java/test/auto_check_sbp_bootload_MsgBootloaderHandshakeRespTest.java index 590babde2..82374671c 100644 --- a/java/test/auto_check_sbp_bootload_MsgBootloaderHandshakeRespTest.java +++ b/java/test/auto_check_sbp_bootload_MsgBootloaderHandshakeRespTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,19 +9,23 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/bootload/test_MsgBootloaderHandshakeResp.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/bootload/test_MsgBootloaderHandshakeResp.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; +import org.junit.Test; + +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; -import com.swiftnav.sbp.bootload.MsgBootloaderHandshakeDepA; + import com.swiftnav.sbp.bootload.MsgBootloaderHandshakeResp; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + +import com.swiftnav.sbp.bootload.MsgBootloaderHandshakeDepA; + public class auto_check_sbp_bootload_MsgBootloaderHandshakeRespTest { @@ -30,35 +35,22 @@ public class auto_check_sbp_bootload_MsgBootloaderHandshakeRespTest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_bootload_MsgBootloaderHandshakeRespTest.test1"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 118, - (byte) 49, - (byte) 46, - (byte) 50, - (byte) 10, - }; - SBPMessage sbp = new SBPMessage(0x0, 0xb4, payload); - MsgBootloaderHandshakeResp msg = new MsgBootloaderHandshakeResp(sbp); + System.out.format("%n%s%n", "auto_check_sbp_bootload_MsgBootloaderHandshakeRespTest.test1"); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)0,(byte)0,(byte)118,(byte)49,(byte)46,(byte)50,(byte)10, }; + SBPMessage sbp = new SBPMessage( 0x0, 0xb4, payload ); + MsgBootloaderHandshakeResp msg = new MsgBootloaderHandshakeResp( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; org.junit.Assert.assertEquals(value, expected); } - org.junit.Assert.assertEquals(msg.version, "v1.2\n"); + org.junit.Assert.assertEquals(msg.version, "v1.2\n" ); org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); } @@ -66,22 +58,16 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_bootload_MsgBootloaderHandshakeRespTest.test2"); - byte[] payload = - new byte[] { - (byte) 118, (byte) 49, (byte) 46, (byte) 50, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0xb0, payload); - MsgBootloaderHandshakeDepA msg = new MsgBootloaderHandshakeDepA(sbp); + System.out.format("%n%s%n", "auto_check_sbp_bootload_MsgBootloaderHandshakeRespTest.test2"); + byte[] payload = new byte[] {(byte)118,(byte)49,(byte)46,(byte)50, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0xb0, payload ); + MsgBootloaderHandshakeDepA msg = new MsgBootloaderHandshakeDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.handshake[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.handshake[0] + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.handshake[0] + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -89,9 +75,7 @@ public void test2() throws Throwable { } value = msg.handshake[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.handshake[1] + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.handshake[1] + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -99,9 +83,7 @@ public void test2() throws Throwable { } value = msg.handshake[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.handshake[2] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.handshake[2] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -109,9 +91,7 @@ public void test2() throws Throwable { } value = msg.handshake[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.handshake[3] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.handshake[3] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; diff --git a/java/test/auto_check_sbp_bootload_MsgBootloaderJumptoAppTest.java b/java/test/auto_check_sbp_bootload_MsgBootloaderJumptoAppTest.java index 01a628461..159cbd06e 100644 --- a/java/test/auto_check_sbp_bootload_MsgBootloaderJumptoAppTest.java +++ b/java/test/auto_check_sbp_bootload_MsgBootloaderJumptoAppTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/bootload/test_MsgBootloaderJumptoApp.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/bootload/test_MsgBootloaderJumptoApp.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.bootload.MsgBootloaderJumpToApp; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_bootload_MsgBootloaderJumptoAppTest { @@ -30,19 +34,15 @@ public class auto_check_sbp_bootload_MsgBootloaderJumptoAppTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_bootload_MsgBootloaderJumptoAppTest.test1"); - byte[] payload = - new byte[] { - (byte) 216, - }; - SBPMessage sbp = new SBPMessage(0x12cd, 0xb1, payload); - MsgBootloaderJumpToApp msg = new MsgBootloaderJumpToApp(sbp); + byte[] payload = new byte[] {(byte)216, }; + SBPMessage sbp = new SBPMessage( 0x12cd, 0xb1, payload ); + MsgBootloaderJumpToApp msg = new MsgBootloaderJumpToApp( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.jump; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.jump + "' != '" + 216 + "'", value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.jump + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; diff --git a/java/test/auto_check_sbp_bootload_MsgNapDeviceDnaReqTest.java b/java/test/auto_check_sbp_bootload_MsgNapDeviceDnaReqTest.java index 87f28342b..02030a09d 100644 --- a/java/test/auto_check_sbp_bootload_MsgNapDeviceDnaReqTest.java +++ b/java/test/auto_check_sbp_bootload_MsgNapDeviceDnaReqTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/bootload/test_MsgNapDeviceDnaReq.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/bootload/test_MsgNapDeviceDnaReq.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; +import org.junit.Test; + +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.bootload.MsgNapDeviceDnaReq; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_bootload_MsgNapDeviceDnaReqTest { @@ -29,9 +34,9 @@ public class auto_check_sbp_bootload_MsgNapDeviceDnaReqTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_bootload_MsgNapDeviceDnaReqTest.test1"); - byte[] payload = new byte[] {}; - SBPMessage sbp = new SBPMessage(0x3280, 0xde, payload); - MsgNapDeviceDnaReq msg = new MsgNapDeviceDnaReq(sbp); + byte[] payload = new byte[] { }; + SBPMessage sbp = new SBPMessage( 0x3280, 0xde, payload ); + MsgNapDeviceDnaReq msg = new MsgNapDeviceDnaReq( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; diff --git a/java/test/auto_check_sbp_bootload_MsgNapDeviceDnaRespTest.java b/java/test/auto_check_sbp_bootload_MsgNapDeviceDnaRespTest.java index 620fa60e4..c25fa7794 100644 --- a/java/test/auto_check_sbp_bootload_MsgNapDeviceDnaRespTest.java +++ b/java/test/auto_check_sbp_bootload_MsgNapDeviceDnaRespTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/bootload/test_MsgNapDeviceDnaResp.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/bootload/test_MsgNapDeviceDnaResp.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.bootload.MsgNapDeviceDnaResp; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_bootload_MsgNapDeviceDnaRespTest { @@ -30,26 +34,15 @@ public class auto_check_sbp_bootload_MsgNapDeviceDnaRespTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_bootload_MsgNapDeviceDnaRespTest.test1"); - byte[] payload = - new byte[] { - (byte) 2, - (byte) 187, - (byte) 1, - (byte) 130, - (byte) 173, - (byte) 244, - (byte) 67, - (byte) 122, - }; - SBPMessage sbp = new SBPMessage(0x38a9, 0xdd, payload); - MsgNapDeviceDnaResp msg = new MsgNapDeviceDnaResp(sbp); + byte[] payload = new byte[] {(byte)2,(byte)187,(byte)1,(byte)130,(byte)173,(byte)244,(byte)67,(byte)122, }; + SBPMessage sbp = new SBPMessage( 0x38a9, 0xdd, payload ); + MsgNapDeviceDnaResp msg = new MsgNapDeviceDnaResp( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.dna[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dna[0] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.dna[0] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -57,9 +50,7 @@ public void test1() throws Throwable { } value = msg.dna[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dna[1] + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.dna[1] + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -67,8 +58,7 @@ public void test1() throws Throwable { } value = msg.dna[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dna[2] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.dna[2] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -76,9 +66,7 @@ public void test1() throws Throwable { } value = msg.dna[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dna[3] + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.dna[3] + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -86,9 +74,7 @@ public void test1() throws Throwable { } value = msg.dna[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dna[4] + "' != '" + 173 + "'", - value.equals(BigInteger.valueOf(173L))); + org.junit.Assert.assertTrue("'" + msg.dna[4] + "' != '" + 173 + "'", value.equals(BigInteger.valueOf( 173L ) ) ); } else { value = value.longValue(); expected = 173L; @@ -96,9 +82,7 @@ public void test1() throws Throwable { } value = msg.dna[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dna[5] + "' != '" + 244 + "'", - value.equals(BigInteger.valueOf(244L))); + org.junit.Assert.assertTrue("'" + msg.dna[5] + "' != '" + 244 + "'", value.equals(BigInteger.valueOf( 244L ) ) ); } else { value = value.longValue(); expected = 244L; @@ -106,8 +90,7 @@ public void test1() throws Throwable { } value = msg.dna[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dna[6] + "' != '" + 67 + "'", value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.dna[6] + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -115,9 +98,7 @@ public void test1() throws Throwable { } value = msg.dna[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dna[7] + "' != '" + 122 + "'", - value.equals(BigInteger.valueOf(122L))); + org.junit.Assert.assertTrue("'" + msg.dna[7] + "' != '" + 122 + "'", value.equals(BigInteger.valueOf( 122L ) ) ); } else { value = value.longValue(); expected = 122L; diff --git a/java/test/auto_check_sbp_ext_events_MsgExtEventTest.java b/java/test/auto_check_sbp_ext_events_MsgExtEventTest.java index 181254490..955b0ec22 100644 --- a/java/test/auto_check_sbp_ext_events_MsgExtEventTest.java +++ b/java/test/auto_check_sbp_ext_events_MsgExtEventTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ext_events/test_MsgExtEvent.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ext_events/test_MsgExtEvent.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ext_events.MsgExtEvent; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ext_events_MsgExtEventTest { @@ -27,31 +32,17 @@ public class auto_check_sbp_ext_events_MsgExtEventTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_ext_events_MsgExtEventTest.test1"); - byte[] payload = - new byte[] { - (byte) 48, - (byte) 7, - (byte) 199, - (byte) 216, - (byte) 49, - (byte) 15, - (byte) 202, - (byte) 65, - (byte) 15, - (byte) 0, - (byte) 3, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x6f5, 0x101, payload); - MsgExtEvent msg = new MsgExtEvent(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_ext_events_MsgExtEventTest.test1"); + byte[] payload = new byte[] {(byte)48,(byte)7,(byte)199,(byte)216,(byte)49,(byte)15,(byte)202,(byte)65,(byte)15,(byte)0,(byte)3,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x6f5, 0x101, payload ); + MsgExtEvent msg = new MsgExtEvent( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -59,9 +50,7 @@ public void test1() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 999882 + "'", - value.equals(BigInteger.valueOf(999882L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 999882 + "'", value.equals(BigInteger.valueOf( 999882L ) ) ); } else { value = value.longValue(); expected = 999882L; @@ -69,8 +58,7 @@ public void test1() throws Throwable { } value = msg.pin; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pin + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.pin + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -78,9 +66,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 254924999 + "'", - value.equals(BigInteger.valueOf(254924999L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 254924999 + "'", value.equals(BigInteger.valueOf( 254924999L ) ) ); } else { value = value.longValue(); expected = 254924999L; @@ -88,8 +74,7 @@ public void test1() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1840 + "'", value.equals(BigInteger.valueOf(1840L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1840 + "'", value.equals(BigInteger.valueOf( 1840L ) ) ); } else { value = value.longValue(); expected = 1840L; diff --git a/java/test/auto_check_sbp_file_io_MsgFileioConfigReqTest.java b/java/test/auto_check_sbp_file_io_MsgFileioConfigReqTest.java index fc79330d3..66abe81be 100644 --- a/java/test/auto_check_sbp_file_io_MsgFileioConfigReqTest.java +++ b/java/test/auto_check_sbp_file_io_MsgFileioConfigReqTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/file_io/test_MsgFileioConfigReq.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/file_io/test_MsgFileioConfigReq.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.file_io.MsgFileioConfigReq; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_file_io_MsgFileioConfigReqTest { @@ -30,20 +34,15 @@ public class auto_check_sbp_file_io_MsgFileioConfigReqTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_file_io_MsgFileioConfigReqTest.test1"); - byte[] payload = - new byte[] { - (byte) 107, (byte) 218, (byte) 69, (byte) 90, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0x1001, payload); - MsgFileioConfigReq msg = new MsgFileioConfigReq(sbp); + byte[] payload = new byte[] {(byte)107,(byte)218,(byte)69,(byte)90, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0x1001, payload ); + MsgFileioConfigReq msg = new MsgFileioConfigReq( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.sequence; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sequence + "' != '" + 1514527339 + "'", - value.equals(BigInteger.valueOf(1514527339L))); + org.junit.Assert.assertTrue("'" + msg.sequence + "' != '" + 1514527339 + "'", value.equals(BigInteger.valueOf( 1514527339L ) ) ); } else { value = value.longValue(); expected = 1514527339L; diff --git a/java/test/auto_check_sbp_file_io_MsgFileioConfigRespTest.java b/java/test/auto_check_sbp_file_io_MsgFileioConfigRespTest.java index 7968df345..1348db05c 100644 --- a/java/test/auto_check_sbp_file_io_MsgFileioConfigRespTest.java +++ b/java/test/auto_check_sbp_file_io_MsgFileioConfigRespTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/file_io/test_MsgFileioConfigResp.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/file_io/test_MsgFileioConfigResp.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.file_io.MsgFileioConfigResp; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_file_io_MsgFileioConfigRespTest { @@ -30,22 +34,15 @@ public class auto_check_sbp_file_io_MsgFileioConfigRespTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_file_io_MsgFileioConfigRespTest.test1"); - byte[] payload = - new byte[] { - (byte) 170, (byte) 76, (byte) 52, (byte) 91, (byte) 149, (byte) 186, (byte) 44, - (byte) 3, (byte) 216, (byte) 151, (byte) 255, (byte) 61, (byte) 12, (byte) 97, - (byte) 66, (byte) 144, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0x1002, payload); - MsgFileioConfigResp msg = new MsgFileioConfigResp(sbp); + byte[] payload = new byte[] {(byte)170,(byte)76,(byte)52,(byte)91,(byte)149,(byte)186,(byte)44,(byte)3,(byte)216,(byte)151,(byte)255,(byte)61,(byte)12,(byte)97,(byte)66,(byte)144, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0x1002, payload ); + MsgFileioConfigResp msg = new MsgFileioConfigResp( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.batch_size; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.batch_size + "' != '" + 1040160728 + "'", - value.equals(BigInteger.valueOf(1040160728L))); + org.junit.Assert.assertTrue("'" + msg.batch_size + "' != '" + 1040160728 + "'", value.equals(BigInteger.valueOf( 1040160728L ) ) ); } else { value = value.longValue(); expected = 1040160728L; @@ -53,9 +50,7 @@ public void test1() throws Throwable { } value = msg.fileio_version; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fileio_version + "' != '" + 2420269324L + "'", - value.equals(new BigInteger("2420269324"))); + org.junit.Assert.assertTrue("'" + msg.fileio_version + "' != '" + 2420269324L + "'", value.equals( new BigInteger( "2420269324" ) ) ); } else { value = value.longValue(); expected = 2420269324L; @@ -63,9 +58,7 @@ public void test1() throws Throwable { } value = msg.sequence; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sequence + "' != '" + 1530154154 + "'", - value.equals(BigInteger.valueOf(1530154154L))); + org.junit.Assert.assertTrue("'" + msg.sequence + "' != '" + 1530154154 + "'", value.equals(BigInteger.valueOf( 1530154154L ) ) ); } else { value = value.longValue(); expected = 1530154154L; @@ -73,9 +66,7 @@ public void test1() throws Throwable { } value = msg.window_size; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.window_size + "' != '" + 53262997 + "'", - value.equals(BigInteger.valueOf(53262997L))); + org.junit.Assert.assertTrue("'" + msg.window_size + "' != '" + 53262997 + "'", value.equals(BigInteger.valueOf( 53262997L ) ) ); } else { value = value.longValue(); expected = 53262997L; diff --git a/java/test/auto_check_sbp_file_io_MsgFileioReadDirReqTest.java b/java/test/auto_check_sbp_file_io_MsgFileioReadDirReqTest.java index 4958cbde4cafd1d47ca9b5b1d4c6d8fe0dc315bd..af61c726493a94256783ac5fbe2d31e5c8064e44 100644 GIT binary patch delta 490 zcmZn^YZqbB*Wyx`$SA>RxKZi| zE#c-G!mT%evk=C?O+zxn2x;rX#LkP+?$_Y^(#M6D@TV3KA=G z@)J`OCeLKEWmPCnDo~hwlWifR!sIIUqREUL1_laci8-aIdZ~q_i8;j@;J|dsO!v$y zNli~J(oj$`GBPzZGBY$YHd9j21j5Y)9Ab=|NgW=G~o#(FLVG?15C4%AnY8Xc=p zjUfqAs{xYLR4_C)(1Edyj13WNQ&TwG5~0M<(hM$aXl$YbHM$S4YyG=W=biDbJWk`D|F@EeWh46Lp;LbJsg5|)N$ z_>DF|xDL}1lNYh-Og_&l%B^V)kFd#sOv00y+2omvlL{uQvn^!Ow4Q9wAv*a1TeK)# z5poDkwq`f5$0}2nm{Xdnms(hwm{Y6)N*zv_>7IEdsp+Xj8cIe+riMmlhGxcQN}8IR vXS0hj;xK+AhoKW;;}J&dfvxpV(=aqOGBY}c98s|a)yt1_a diff --git a/java/test/auto_check_sbp_file_io_MsgFileioReadDirRespTest.java b/java/test/auto_check_sbp_file_io_MsgFileioReadDirRespTest.java index d93b8fd2419b987b1dc728539369df5e7a0e097c..a1f7a555f3ecc98da0ebffcd3c29707d3f016832 100644 GIT binary patch delta 641 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 H^icXA@cqKQ diff --git a/java/test/auto_check_sbp_file_io_MsgFileioReadRespTest.java b/java/test/auto_check_sbp_file_io_MsgFileioReadRespTest.java index d7f52c829..de0418d7e 100644 --- a/java/test/auto_check_sbp_file_io_MsgFileioReadRespTest.java +++ b/java/test/auto_check_sbp_file_io_MsgFileioReadRespTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/file_io/test_MsgFileioReadResp.yaml by generate.py. Do not modify by -// hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/file_io/test_MsgFileioReadResp.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.file_io.MsgFileioReadResp; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_file_io_MsgFileioReadRespTest { @@ -30,274 +34,15 @@ public class auto_check_sbp_file_io_MsgFileioReadRespTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_file_io_MsgFileioReadRespTest.test1"); - byte[] payload = - new byte[] { - (byte) 67, - (byte) 183, - (byte) 115, - (byte) 15, - (byte) 73, - (byte) 231, - (byte) 227, - (byte) 179, - (byte) 18, - (byte) 76, - (byte) 68, - (byte) 229, - (byte) 216, - (byte) 21, - (byte) 98, - (byte) 183, - (byte) 69, - (byte) 190, - (byte) 5, - (byte) 252, - (byte) 176, - (byte) 55, - (byte) 32, - (byte) 78, - (byte) 8, - (byte) 52, - (byte) 127, - (byte) 50, - (byte) 71, - (byte) 106, - (byte) 61, - (byte) 79, - (byte) 191, - (byte) 106, - (byte) 46, - (byte) 79, - (byte) 118, - (byte) 248, - (byte) 118, - (byte) 207, - (byte) 206, - (byte) 210, - (byte) 91, - (byte) 73, - (byte) 251, - (byte) 81, - (byte) 131, - (byte) 205, - (byte) 193, - (byte) 146, - (byte) 206, - (byte) 185, - (byte) 140, - (byte) 249, - (byte) 163, - (byte) 231, - (byte) 65, - (byte) 67, - (byte) 94, - (byte) 250, - (byte) 109, - (byte) 152, - (byte) 95, - (byte) 123, - (byte) 77, - (byte) 224, - (byte) 124, - (byte) 238, - (byte) 205, - (byte) 65, - (byte) 103, - (byte) 35, - (byte) 104, - (byte) 209, - (byte) 5, - (byte) 191, - (byte) 47, - (byte) 249, - (byte) 176, - (byte) 166, - (byte) 213, - (byte) 46, - (byte) 192, - (byte) 86, - (byte) 32, - (byte) 103, - (byte) 146, - (byte) 252, - (byte) 4, - (byte) 16, - (byte) 54, - (byte) 161, - (byte) 60, - (byte) 6, - (byte) 13, - (byte) 191, - (byte) 116, - (byte) 182, - (byte) 42, - (byte) 191, - (byte) 213, - (byte) 20, - (byte) 217, - (byte) 8, - (byte) 142, - (byte) 187, - (byte) 238, - (byte) 120, - (byte) 184, - (byte) 250, - (byte) 31, - (byte) 151, - (byte) 37, - (byte) 51, - (byte) 177, - (byte) 130, - (byte) 190, - (byte) 155, - (byte) 71, - (byte) 68, - (byte) 56, - (byte) 238, - (byte) 92, - (byte) 130, - (byte) 37, - (byte) 137, - (byte) 146, - (byte) 246, - (byte) 114, - (byte) 116, - (byte) 138, - (byte) 165, - (byte) 217, - (byte) 79, - (byte) 10, - (byte) 189, - (byte) 128, - (byte) 189, - (byte) 2, - (byte) 240, - (byte) 92, - (byte) 28, - (byte) 126, - (byte) 105, - (byte) 236, - (byte) 228, - (byte) 194, - (byte) 0, - (byte) 51, - (byte) 61, - (byte) 74, - (byte) 41, - (byte) 10, - (byte) 239, - (byte) 133, - (byte) 106, - (byte) 190, - (byte) 30, - (byte) 27, - (byte) 3, - (byte) 240, - (byte) 205, - (byte) 253, - (byte) 113, - (byte) 25, - (byte) 28, - (byte) 187, - (byte) 81, - (byte) 101, - (byte) 216, - (byte) 121, - (byte) 41, - (byte) 179, - (byte) 120, - (byte) 152, - (byte) 18, - (byte) 116, - (byte) 53, - (byte) 212, - (byte) 100, - (byte) 2, - (byte) 114, - (byte) 198, - (byte) 200, - (byte) 10, - (byte) 147, - (byte) 25, - (byte) 33, - (byte) 115, - (byte) 208, - (byte) 113, - (byte) 60, - (byte) 179, - (byte) 183, - (byte) 0, - (byte) 41, - (byte) 217, - (byte) 206, - (byte) 255, - (byte) 211, - (byte) 225, - (byte) 142, - (byte) 191, - (byte) 133, - (byte) 81, - (byte) 15, - (byte) 248, - (byte) 193, - (byte) 66, - (byte) 191, - (byte) 244, - (byte) 221, - (byte) 248, - (byte) 199, - (byte) 241, - (byte) 112, - (byte) 51, - (byte) 1, - (byte) 180, - (byte) 180, - (byte) 125, - (byte) 97, - (byte) 145, - (byte) 25, - (byte) 72, - (byte) 210, - (byte) 215, - (byte) 208, - (byte) 15, - (byte) 126, - (byte) 56, - (byte) 38, - (byte) 65, - (byte) 4, - (byte) 64, - (byte) 19, - (byte) 74, - (byte) 223, - (byte) 111, - (byte) 109, - (byte) 52, - (byte) 43, - (byte) 167, - (byte) 186, - (byte) 202, - (byte) 111, - (byte) 11, - (byte) 91, - (byte) 21, - (byte) 236, - (byte) 234, - (byte) 196, - (byte) 36, - (byte) 171, - (byte) 147, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0xa3, payload); - MsgFileioReadResp msg = new MsgFileioReadResp(sbp); + byte[] payload = new byte[] {(byte)67,(byte)183,(byte)115,(byte)15,(byte)73,(byte)231,(byte)227,(byte)179,(byte)18,(byte)76,(byte)68,(byte)229,(byte)216,(byte)21,(byte)98,(byte)183,(byte)69,(byte)190,(byte)5,(byte)252,(byte)176,(byte)55,(byte)32,(byte)78,(byte)8,(byte)52,(byte)127,(byte)50,(byte)71,(byte)106,(byte)61,(byte)79,(byte)191,(byte)106,(byte)46,(byte)79,(byte)118,(byte)248,(byte)118,(byte)207,(byte)206,(byte)210,(byte)91,(byte)73,(byte)251,(byte)81,(byte)131,(byte)205,(byte)193,(byte)146,(byte)206,(byte)185,(byte)140,(byte)249,(byte)163,(byte)231,(byte)65,(byte)67,(byte)94,(byte)250,(byte)109,(byte)152,(byte)95,(byte)123,(byte)77,(byte)224,(byte)124,(byte)238,(byte)205,(byte)65,(byte)103,(byte)35,(byte)104,(byte)209,(byte)5,(byte)191,(byte)47,(byte)249,(byte)176,(byte)166,(byte)213,(byte)46,(byte)192,(byte)86,(byte)32,(byte)103,(byte)146,(byte)252,(byte)4,(byte)16,(byte)54,(byte)161,(byte)60,(byte)6,(byte)13,(byte)191,(byte)116,(byte)182,(byte)42,(byte)191,(byte)213,(byte)20,(byte)217,(byte)8,(byte)142,(byte)187,(byte)238,(byte)120,(byte)184,(byte)250,(byte)31,(byte)151,(byte)37,(byte)51,(byte)177,(byte)130,(byte)190,(byte)155,(byte)71,(byte)68,(byte)56,(byte)238,(byte)92,(byte)130,(byte)37,(byte)137,(byte)146,(byte)246,(byte)114,(byte)116,(byte)138,(byte)165,(byte)217,(byte)79,(byte)10,(byte)189,(byte)128,(byte)189,(byte)2,(byte)240,(byte)92,(byte)28,(byte)126,(byte)105,(byte)236,(byte)228,(byte)194,(byte)0,(byte)51,(byte)61,(byte)74,(byte)41,(byte)10,(byte)239,(byte)133,(byte)106,(byte)190,(byte)30,(byte)27,(byte)3,(byte)240,(byte)205,(byte)253,(byte)113,(byte)25,(byte)28,(byte)187,(byte)81,(byte)101,(byte)216,(byte)121,(byte)41,(byte)179,(byte)120,(byte)152,(byte)18,(byte)116,(byte)53,(byte)212,(byte)100,(byte)2,(byte)114,(byte)198,(byte)200,(byte)10,(byte)147,(byte)25,(byte)33,(byte)115,(byte)208,(byte)113,(byte)60,(byte)179,(byte)183,(byte)0,(byte)41,(byte)217,(byte)206,(byte)255,(byte)211,(byte)225,(byte)142,(byte)191,(byte)133,(byte)81,(byte)15,(byte)248,(byte)193,(byte)66,(byte)191,(byte)244,(byte)221,(byte)248,(byte)199,(byte)241,(byte)112,(byte)51,(byte)1,(byte)180,(byte)180,(byte)125,(byte)97,(byte)145,(byte)25,(byte)72,(byte)210,(byte)215,(byte)208,(byte)15,(byte)126,(byte)56,(byte)38,(byte)65,(byte)4,(byte)64,(byte)19,(byte)74,(byte)223,(byte)111,(byte)109,(byte)52,(byte)43,(byte)167,(byte)186,(byte)202,(byte)111,(byte)11,(byte)91,(byte)21,(byte)236,(byte)234,(byte)196,(byte)36,(byte)171,(byte)147, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0xa3, payload ); + MsgFileioReadResp msg = new MsgFileioReadResp( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.contents[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[0] + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.contents[0] + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -305,9 +50,7 @@ public void test1() throws Throwable { } value = msg.contents[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[1] + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.contents[1] + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -315,9 +58,7 @@ public void test1() throws Throwable { } value = msg.contents[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[2] + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.contents[2] + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -325,9 +66,7 @@ public void test1() throws Throwable { } value = msg.contents[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[3] + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.contents[3] + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -335,9 +74,7 @@ public void test1() throws Throwable { } value = msg.contents[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[4] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.contents[4] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -345,9 +82,7 @@ public void test1() throws Throwable { } value = msg.contents[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[5] + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.contents[5] + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -355,9 +90,7 @@ public void test1() throws Throwable { } value = msg.contents[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[6] + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.contents[6] + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -365,9 +98,7 @@ public void test1() throws Throwable { } value = msg.contents[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[7] + "' != '" + 229 + "'", - value.equals(BigInteger.valueOf(229L))); + org.junit.Assert.assertTrue("'" + msg.contents[7] + "' != '" + 229 + "'", value.equals(BigInteger.valueOf( 229L ) ) ); } else { value = value.longValue(); expected = 229L; @@ -375,9 +106,7 @@ public void test1() throws Throwable { } value = msg.contents[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[8] + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.contents[8] + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -385,9 +114,7 @@ public void test1() throws Throwable { } value = msg.contents[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[9] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.contents[9] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -395,9 +122,7 @@ public void test1() throws Throwable { } value = msg.contents[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[10] + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.contents[10] + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -405,9 +130,7 @@ public void test1() throws Throwable { } value = msg.contents[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[11] + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.contents[11] + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -415,9 +138,7 @@ public void test1() throws Throwable { } value = msg.contents[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[12] + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.contents[12] + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -425,9 +146,7 @@ public void test1() throws Throwable { } value = msg.contents[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[13] + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.contents[13] + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -435,9 +154,7 @@ public void test1() throws Throwable { } value = msg.contents[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[14] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.contents[14] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -445,9 +162,7 @@ public void test1() throws Throwable { } value = msg.contents[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[15] + "' != '" + 252 + "'", - value.equals(BigInteger.valueOf(252L))); + org.junit.Assert.assertTrue("'" + msg.contents[15] + "' != '" + 252 + "'", value.equals(BigInteger.valueOf( 252L ) ) ); } else { value = value.longValue(); expected = 252L; @@ -455,9 +170,7 @@ public void test1() throws Throwable { } value = msg.contents[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[16] + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.contents[16] + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -465,9 +178,7 @@ public void test1() throws Throwable { } value = msg.contents[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[17] + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.contents[17] + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -475,9 +186,7 @@ public void test1() throws Throwable { } value = msg.contents[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[18] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.contents[18] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -485,9 +194,7 @@ public void test1() throws Throwable { } value = msg.contents[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[19] + "' != '" + 78 + "'", - value.equals(BigInteger.valueOf(78L))); + org.junit.Assert.assertTrue("'" + msg.contents[19] + "' != '" + 78 + "'", value.equals(BigInteger.valueOf( 78L ) ) ); } else { value = value.longValue(); expected = 78L; @@ -495,9 +202,7 @@ public void test1() throws Throwable { } value = msg.contents[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[20] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.contents[20] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -505,9 +210,7 @@ public void test1() throws Throwable { } value = msg.contents[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[21] + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.contents[21] + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -515,9 +218,7 @@ public void test1() throws Throwable { } value = msg.contents[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[22] + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.contents[22] + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -525,9 +226,7 @@ public void test1() throws Throwable { } value = msg.contents[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[23] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.contents[23] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -535,9 +234,7 @@ public void test1() throws Throwable { } value = msg.contents[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[24] + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.contents[24] + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -545,9 +242,7 @@ public void test1() throws Throwable { } value = msg.contents[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[25] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.contents[25] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -555,9 +250,7 @@ public void test1() throws Throwable { } value = msg.contents[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[26] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.contents[26] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -565,9 +258,7 @@ public void test1() throws Throwable { } value = msg.contents[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[27] + "' != '" + 79 + "'", - value.equals(BigInteger.valueOf(79L))); + org.junit.Assert.assertTrue("'" + msg.contents[27] + "' != '" + 79 + "'", value.equals(BigInteger.valueOf( 79L ) ) ); } else { value = value.longValue(); expected = 79L; @@ -575,9 +266,7 @@ public void test1() throws Throwable { } value = msg.contents[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[28] + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.contents[28] + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -585,9 +274,7 @@ public void test1() throws Throwable { } value = msg.contents[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[29] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.contents[29] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -595,9 +282,7 @@ public void test1() throws Throwable { } value = msg.contents[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[30] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.contents[30] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -605,9 +290,7 @@ public void test1() throws Throwable { } value = msg.contents[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[31] + "' != '" + 79 + "'", - value.equals(BigInteger.valueOf(79L))); + org.junit.Assert.assertTrue("'" + msg.contents[31] + "' != '" + 79 + "'", value.equals(BigInteger.valueOf( 79L ) ) ); } else { value = value.longValue(); expected = 79L; @@ -615,9 +298,7 @@ public void test1() throws Throwable { } value = msg.contents[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[32] + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.contents[32] + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -625,9 +306,7 @@ public void test1() throws Throwable { } value = msg.contents[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[33] + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.contents[33] + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -635,9 +314,7 @@ public void test1() throws Throwable { } value = msg.contents[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[34] + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.contents[34] + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -645,9 +322,7 @@ public void test1() throws Throwable { } value = msg.contents[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[35] + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.contents[35] + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -655,9 +330,7 @@ public void test1() throws Throwable { } value = msg.contents[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[36] + "' != '" + 206 + "'", - value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.contents[36] + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; @@ -665,9 +338,7 @@ public void test1() throws Throwable { } value = msg.contents[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[37] + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.contents[37] + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -675,9 +346,7 @@ public void test1() throws Throwable { } value = msg.contents[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[38] + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.contents[38] + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -685,9 +354,7 @@ public void test1() throws Throwable { } value = msg.contents[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[39] + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.contents[39] + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -695,9 +362,7 @@ public void test1() throws Throwable { } value = msg.contents[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[40] + "' != '" + 251 + "'", - value.equals(BigInteger.valueOf(251L))); + org.junit.Assert.assertTrue("'" + msg.contents[40] + "' != '" + 251 + "'", value.equals(BigInteger.valueOf( 251L ) ) ); } else { value = value.longValue(); expected = 251L; @@ -705,9 +370,7 @@ public void test1() throws Throwable { } value = msg.contents[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[41] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.contents[41] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -715,9 +378,7 @@ public void test1() throws Throwable { } value = msg.contents[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[42] + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.contents[42] + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -725,9 +386,7 @@ public void test1() throws Throwable { } value = msg.contents[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[43] + "' != '" + 205 + "'", - value.equals(BigInteger.valueOf(205L))); + org.junit.Assert.assertTrue("'" + msg.contents[43] + "' != '" + 205 + "'", value.equals(BigInteger.valueOf( 205L ) ) ); } else { value = value.longValue(); expected = 205L; @@ -735,9 +394,7 @@ public void test1() throws Throwable { } value = msg.contents[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[44] + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.contents[44] + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -745,9 +402,7 @@ public void test1() throws Throwable { } value = msg.contents[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[45] + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.contents[45] + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -755,9 +410,7 @@ public void test1() throws Throwable { } value = msg.contents[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[46] + "' != '" + 206 + "'", - value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.contents[46] + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; @@ -765,9 +418,7 @@ public void test1() throws Throwable { } value = msg.contents[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[47] + "' != '" + 185 + "'", - value.equals(BigInteger.valueOf(185L))); + org.junit.Assert.assertTrue("'" + msg.contents[47] + "' != '" + 185 + "'", value.equals(BigInteger.valueOf( 185L ) ) ); } else { value = value.longValue(); expected = 185L; @@ -775,9 +426,7 @@ public void test1() throws Throwable { } value = msg.contents[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[48] + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.contents[48] + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -785,9 +434,7 @@ public void test1() throws Throwable { } value = msg.contents[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[49] + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.contents[49] + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -795,9 +442,7 @@ public void test1() throws Throwable { } value = msg.contents[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[50] + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.contents[50] + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -805,9 +450,7 @@ public void test1() throws Throwable { } value = msg.contents[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[51] + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.contents[51] + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -815,9 +458,7 @@ public void test1() throws Throwable { } value = msg.contents[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[52] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.contents[52] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -825,9 +466,7 @@ public void test1() throws Throwable { } value = msg.contents[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[53] + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.contents[53] + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -835,9 +474,7 @@ public void test1() throws Throwable { } value = msg.contents[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[54] + "' != '" + 94 + "'", - value.equals(BigInteger.valueOf(94L))); + org.junit.Assert.assertTrue("'" + msg.contents[54] + "' != '" + 94 + "'", value.equals(BigInteger.valueOf( 94L ) ) ); } else { value = value.longValue(); expected = 94L; @@ -845,9 +482,7 @@ public void test1() throws Throwable { } value = msg.contents[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[55] + "' != '" + 250 + "'", - value.equals(BigInteger.valueOf(250L))); + org.junit.Assert.assertTrue("'" + msg.contents[55] + "' != '" + 250 + "'", value.equals(BigInteger.valueOf( 250L ) ) ); } else { value = value.longValue(); expected = 250L; @@ -855,9 +490,7 @@ public void test1() throws Throwable { } value = msg.contents[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[56] + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.contents[56] + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -865,9 +498,7 @@ public void test1() throws Throwable { } value = msg.contents[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[57] + "' != '" + 152 + "'", - value.equals(BigInteger.valueOf(152L))); + org.junit.Assert.assertTrue("'" + msg.contents[57] + "' != '" + 152 + "'", value.equals(BigInteger.valueOf( 152L ) ) ); } else { value = value.longValue(); expected = 152L; @@ -875,9 +506,7 @@ public void test1() throws Throwable { } value = msg.contents[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[58] + "' != '" + 95 + "'", - value.equals(BigInteger.valueOf(95L))); + org.junit.Assert.assertTrue("'" + msg.contents[58] + "' != '" + 95 + "'", value.equals(BigInteger.valueOf( 95L ) ) ); } else { value = value.longValue(); expected = 95L; @@ -885,9 +514,7 @@ public void test1() throws Throwable { } value = msg.contents[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[59] + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.contents[59] + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -895,9 +522,7 @@ public void test1() throws Throwable { } value = msg.contents[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[60] + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.contents[60] + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -905,9 +530,7 @@ public void test1() throws Throwable { } value = msg.contents[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[61] + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.contents[61] + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -915,9 +538,7 @@ public void test1() throws Throwable { } value = msg.contents[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[62] + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.contents[62] + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -925,9 +546,7 @@ public void test1() throws Throwable { } value = msg.contents[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[63] + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.contents[63] + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -935,9 +554,7 @@ public void test1() throws Throwable { } value = msg.contents[64]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[64] + "' != '" + 205 + "'", - value.equals(BigInteger.valueOf(205L))); + org.junit.Assert.assertTrue("'" + msg.contents[64] + "' != '" + 205 + "'", value.equals(BigInteger.valueOf( 205L ) ) ); } else { value = value.longValue(); expected = 205L; @@ -945,9 +562,7 @@ public void test1() throws Throwable { } value = msg.contents[65]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[65] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.contents[65] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -955,9 +570,7 @@ public void test1() throws Throwable { } value = msg.contents[66]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[66] + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.contents[66] + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -965,9 +578,7 @@ public void test1() throws Throwable { } value = msg.contents[67]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[67] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.contents[67] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -975,9 +586,7 @@ public void test1() throws Throwable { } value = msg.contents[68]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[68] + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.contents[68] + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -985,9 +594,7 @@ public void test1() throws Throwable { } value = msg.contents[69]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[69] + "' != '" + 209 + "'", - value.equals(BigInteger.valueOf(209L))); + org.junit.Assert.assertTrue("'" + msg.contents[69] + "' != '" + 209 + "'", value.equals(BigInteger.valueOf( 209L ) ) ); } else { value = value.longValue(); expected = 209L; @@ -995,9 +602,7 @@ public void test1() throws Throwable { } value = msg.contents[70]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[70] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.contents[70] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -1005,9 +610,7 @@ public void test1() throws Throwable { } value = msg.contents[71]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[71] + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.contents[71] + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -1015,9 +618,7 @@ public void test1() throws Throwable { } value = msg.contents[72]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[72] + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.contents[72] + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -1025,9 +626,7 @@ public void test1() throws Throwable { } value = msg.contents[73]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[73] + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.contents[73] + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -1035,9 +634,7 @@ public void test1() throws Throwable { } value = msg.contents[74]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[74] + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.contents[74] + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -1045,9 +642,7 @@ public void test1() throws Throwable { } value = msg.contents[75]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[75] + "' != '" + 166 + "'", - value.equals(BigInteger.valueOf(166L))); + org.junit.Assert.assertTrue("'" + msg.contents[75] + "' != '" + 166 + "'", value.equals(BigInteger.valueOf( 166L ) ) ); } else { value = value.longValue(); expected = 166L; @@ -1055,9 +650,7 @@ public void test1() throws Throwable { } value = msg.contents[76]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[76] + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.contents[76] + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -1065,9 +658,7 @@ public void test1() throws Throwable { } value = msg.contents[77]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[77] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.contents[77] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -1075,9 +666,7 @@ public void test1() throws Throwable { } value = msg.contents[78]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[78] + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.contents[78] + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -1085,9 +674,7 @@ public void test1() throws Throwable { } value = msg.contents[79]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[79] + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.contents[79] + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -1095,9 +682,7 @@ public void test1() throws Throwable { } value = msg.contents[80]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[80] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.contents[80] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -1105,9 +690,7 @@ public void test1() throws Throwable { } value = msg.contents[81]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[81] + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.contents[81] + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -1115,9 +698,7 @@ public void test1() throws Throwable { } value = msg.contents[82]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[82] + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.contents[82] + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -1125,9 +706,7 @@ public void test1() throws Throwable { } value = msg.contents[83]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[83] + "' != '" + 252 + "'", - value.equals(BigInteger.valueOf(252L))); + org.junit.Assert.assertTrue("'" + msg.contents[83] + "' != '" + 252 + "'", value.equals(BigInteger.valueOf( 252L ) ) ); } else { value = value.longValue(); expected = 252L; @@ -1135,9 +714,7 @@ public void test1() throws Throwable { } value = msg.contents[84]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[84] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.contents[84] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1145,9 +722,7 @@ public void test1() throws Throwable { } value = msg.contents[85]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[85] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.contents[85] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -1155,9 +730,7 @@ public void test1() throws Throwable { } value = msg.contents[86]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[86] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.contents[86] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -1165,9 +738,7 @@ public void test1() throws Throwable { } value = msg.contents[87]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[87] + "' != '" + 161 + "'", - value.equals(BigInteger.valueOf(161L))); + org.junit.Assert.assertTrue("'" + msg.contents[87] + "' != '" + 161 + "'", value.equals(BigInteger.valueOf( 161L ) ) ); } else { value = value.longValue(); expected = 161L; @@ -1175,9 +746,7 @@ public void test1() throws Throwable { } value = msg.contents[88]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[88] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.contents[88] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -1185,9 +754,7 @@ public void test1() throws Throwable { } value = msg.contents[89]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[89] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.contents[89] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1195,9 +762,7 @@ public void test1() throws Throwable { } value = msg.contents[90]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[90] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.contents[90] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -1205,9 +770,7 @@ public void test1() throws Throwable { } value = msg.contents[91]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[91] + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.contents[91] + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -1215,9 +778,7 @@ public void test1() throws Throwable { } value = msg.contents[92]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[92] + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.contents[92] + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1225,9 +786,7 @@ public void test1() throws Throwable { } value = msg.contents[93]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[93] + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.contents[93] + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -1235,9 +794,7 @@ public void test1() throws Throwable { } value = msg.contents[94]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[94] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.contents[94] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -1245,9 +802,7 @@ public void test1() throws Throwable { } value = msg.contents[95]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[95] + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.contents[95] + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -1255,9 +810,7 @@ public void test1() throws Throwable { } value = msg.contents[96]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[96] + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.contents[96] + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -1265,9 +818,7 @@ public void test1() throws Throwable { } value = msg.contents[97]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[97] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.contents[97] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -1275,9 +826,7 @@ public void test1() throws Throwable { } value = msg.contents[98]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[98] + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.contents[98] + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -1285,9 +834,7 @@ public void test1() throws Throwable { } value = msg.contents[99]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[99] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.contents[99] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -1295,9 +842,7 @@ public void test1() throws Throwable { } value = msg.contents[100]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[100] + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.contents[100] + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -1305,9 +850,7 @@ public void test1() throws Throwable { } value = msg.contents[101]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[101] + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.contents[101] + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -1315,9 +858,7 @@ public void test1() throws Throwable { } value = msg.contents[102]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[102] + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.contents[102] + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -1325,9 +866,7 @@ public void test1() throws Throwable { } value = msg.contents[103]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[103] + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.contents[103] + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -1335,9 +874,7 @@ public void test1() throws Throwable { } value = msg.contents[104]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[104] + "' != '" + 184 + "'", - value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.contents[104] + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -1345,9 +882,7 @@ public void test1() throws Throwable { } value = msg.contents[105]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[105] + "' != '" + 250 + "'", - value.equals(BigInteger.valueOf(250L))); + org.junit.Assert.assertTrue("'" + msg.contents[105] + "' != '" + 250 + "'", value.equals(BigInteger.valueOf( 250L ) ) ); } else { value = value.longValue(); expected = 250L; @@ -1355,9 +890,7 @@ public void test1() throws Throwable { } value = msg.contents[106]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[106] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.contents[106] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -1365,9 +898,7 @@ public void test1() throws Throwable { } value = msg.contents[107]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[107] + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.contents[107] + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -1375,9 +906,7 @@ public void test1() throws Throwable { } value = msg.contents[108]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[108] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.contents[108] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -1385,9 +914,7 @@ public void test1() throws Throwable { } value = msg.contents[109]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[109] + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.contents[109] + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -1395,9 +922,7 @@ public void test1() throws Throwable { } value = msg.contents[110]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[110] + "' != '" + 177 + "'", - value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.contents[110] + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -1405,9 +930,7 @@ public void test1() throws Throwable { } value = msg.contents[111]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[111] + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.contents[111] + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -1415,9 +938,7 @@ public void test1() throws Throwable { } value = msg.contents[112]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[112] + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.contents[112] + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -1425,9 +946,7 @@ public void test1() throws Throwable { } value = msg.contents[113]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[113] + "' != '" + 155 + "'", - value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.contents[113] + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -1435,9 +954,7 @@ public void test1() throws Throwable { } value = msg.contents[114]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[114] + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.contents[114] + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -1445,9 +962,7 @@ public void test1() throws Throwable { } value = msg.contents[115]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[115] + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.contents[115] + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -1455,9 +970,7 @@ public void test1() throws Throwable { } value = msg.contents[116]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[116] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.contents[116] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -1465,9 +978,7 @@ public void test1() throws Throwable { } value = msg.contents[117]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[117] + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.contents[117] + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -1475,9 +986,7 @@ public void test1() throws Throwable { } value = msg.contents[118]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[118] + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.contents[118] + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -1485,9 +994,7 @@ public void test1() throws Throwable { } value = msg.contents[119]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[119] + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.contents[119] + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -1495,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.contents[120]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[120] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.contents[120] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -1505,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.contents[121]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[121] + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.contents[121] + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -1515,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.contents[122]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[122] + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.contents[122] + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -1525,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.contents[123]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[123] + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.contents[123] + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -1535,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.contents[124]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[124] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.contents[124] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -1545,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.contents[125]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[125] + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.contents[125] + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1555,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.contents[126]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[126] + "' != '" + 138 + "'", - value.equals(BigInteger.valueOf(138L))); + org.junit.Assert.assertTrue("'" + msg.contents[126] + "' != '" + 138 + "'", value.equals(BigInteger.valueOf( 138L ) ) ); } else { value = value.longValue(); expected = 138L; @@ -1565,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.contents[127]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[127] + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.contents[127] + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -1575,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.contents[128]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[128] + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.contents[128] + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -1585,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.contents[129]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[129] + "' != '" + 79 + "'", - value.equals(BigInteger.valueOf(79L))); + org.junit.Assert.assertTrue("'" + msg.contents[129] + "' != '" + 79 + "'", value.equals(BigInteger.valueOf( 79L ) ) ); } else { value = value.longValue(); expected = 79L; @@ -1595,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.contents[130]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[130] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.contents[130] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -1605,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.contents[131]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[131] + "' != '" + 189 + "'", - value.equals(BigInteger.valueOf(189L))); + org.junit.Assert.assertTrue("'" + msg.contents[131] + "' != '" + 189 + "'", value.equals(BigInteger.valueOf( 189L ) ) ); } else { value = value.longValue(); expected = 189L; @@ -1615,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.contents[132]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[132] + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.contents[132] + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -1625,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.contents[133]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[133] + "' != '" + 189 + "'", - value.equals(BigInteger.valueOf(189L))); + org.junit.Assert.assertTrue("'" + msg.contents[133] + "' != '" + 189 + "'", value.equals(BigInteger.valueOf( 189L ) ) ); } else { value = value.longValue(); expected = 189L; @@ -1635,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.contents[134]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[134] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.contents[134] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1645,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.contents[135]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[135] + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.contents[135] + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -1655,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.contents[136]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[136] + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.contents[136] + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -1665,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.contents[137]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[137] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.contents[137] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -1675,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.contents[138]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[138] + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.contents[138] + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -1685,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.contents[139]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[139] + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.contents[139] + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -1695,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.contents[140]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[140] + "' != '" + 236 + "'", - value.equals(BigInteger.valueOf(236L))); + org.junit.Assert.assertTrue("'" + msg.contents[140] + "' != '" + 236 + "'", value.equals(BigInteger.valueOf( 236L ) ) ); } else { value = value.longValue(); expected = 236L; @@ -1705,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.contents[141]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[141] + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.contents[141] + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -1715,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.contents[142]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[142] + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.contents[142] + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -1725,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.contents[143]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[143] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.contents[143] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1735,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.contents[144]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[144] + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.contents[144] + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -1745,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.contents[145]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[145] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.contents[145] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -1755,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.contents[146]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[146] + "' != '" + 74 + "'", - value.equals(BigInteger.valueOf(74L))); + org.junit.Assert.assertTrue("'" + msg.contents[146] + "' != '" + 74 + "'", value.equals(BigInteger.valueOf( 74L ) ) ); } else { value = value.longValue(); expected = 74L; @@ -1765,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.contents[147]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[147] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.contents[147] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -1775,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.contents[148]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[148] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.contents[148] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -1785,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.contents[149]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[149] + "' != '" + 239 + "'", - value.equals(BigInteger.valueOf(239L))); + org.junit.Assert.assertTrue("'" + msg.contents[149] + "' != '" + 239 + "'", value.equals(BigInteger.valueOf( 239L ) ) ); } else { value = value.longValue(); expected = 239L; @@ -1795,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.contents[150]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[150] + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.contents[150] + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -1805,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.contents[151]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[151] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.contents[151] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -1815,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.contents[152]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[152] + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.contents[152] + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -1825,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.contents[153]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[153] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.contents[153] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -1835,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.contents[154]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[154] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.contents[154] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -1845,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.contents[155]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[155] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.contents[155] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1855,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.contents[156]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[156] + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.contents[156] + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -1865,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.contents[157]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[157] + "' != '" + 205 + "'", - value.equals(BigInteger.valueOf(205L))); + org.junit.Assert.assertTrue("'" + msg.contents[157] + "' != '" + 205 + "'", value.equals(BigInteger.valueOf( 205L ) ) ); } else { value = value.longValue(); expected = 205L; @@ -1875,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.contents[158]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[158] + "' != '" + 253 + "'", - value.equals(BigInteger.valueOf(253L))); + org.junit.Assert.assertTrue("'" + msg.contents[158] + "' != '" + 253 + "'", value.equals(BigInteger.valueOf( 253L ) ) ); } else { value = value.longValue(); expected = 253L; @@ -1885,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.contents[159]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[159] + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.contents[159] + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -1895,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.contents[160]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[160] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.contents[160] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -1905,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.contents[161]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[161] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.contents[161] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -1915,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.contents[162]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[162] + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.contents[162] + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -1925,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.contents[163]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[163] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.contents[163] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -1935,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.contents[164]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[164] + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.contents[164] + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -1945,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.contents[165]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[165] + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.contents[165] + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -1955,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.contents[166]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[166] + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.contents[166] + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -1965,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.contents[167]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[167] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.contents[167] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -1975,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.contents[168]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[168] + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.contents[168] + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -1985,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.contents[169]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[169] + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.contents[169] + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -1995,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.contents[170]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[170] + "' != '" + 152 + "'", - value.equals(BigInteger.valueOf(152L))); + org.junit.Assert.assertTrue("'" + msg.contents[170] + "' != '" + 152 + "'", value.equals(BigInteger.valueOf( 152L ) ) ); } else { value = value.longValue(); expected = 152L; @@ -2005,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.contents[171]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[171] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.contents[171] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -2015,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.contents[172]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[172] + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.contents[172] + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -2025,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.contents[173]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[173] + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.contents[173] + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -2035,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.contents[174]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[174] + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.contents[174] + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -2045,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.contents[175]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[175] + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.contents[175] + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -2055,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.contents[176]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[176] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.contents[176] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -2065,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.contents[177]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[177] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.contents[177] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -2075,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.contents[178]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[178] + "' != '" + 198 + "'", - value.equals(BigInteger.valueOf(198L))); + org.junit.Assert.assertTrue("'" + msg.contents[178] + "' != '" + 198 + "'", value.equals(BigInteger.valueOf( 198L ) ) ); } else { value = value.longValue(); expected = 198L; @@ -2085,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.contents[179]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[179] + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.contents[179] + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -2095,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.contents[180]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[180] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.contents[180] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -2105,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.contents[181]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[181] + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.contents[181] + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -2115,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.contents[182]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[182] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.contents[182] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -2125,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.contents[183]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[183] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.contents[183] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -2135,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.contents[184]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[184] + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.contents[184] + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -2145,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.contents[185]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[185] + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.contents[185] + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -2155,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.contents[186]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[186] + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.contents[186] + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -2165,9 +1538,7 @@ public void test1() throws Throwable { } value = msg.contents[187]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[187] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.contents[187] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -2175,9 +1546,7 @@ public void test1() throws Throwable { } value = msg.contents[188]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[188] + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.contents[188] + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -2185,9 +1554,7 @@ public void test1() throws Throwable { } value = msg.contents[189]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[189] + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.contents[189] + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -2195,9 +1562,7 @@ public void test1() throws Throwable { } value = msg.contents[190]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[190] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.contents[190] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2205,9 +1570,7 @@ public void test1() throws Throwable { } value = msg.contents[191]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[191] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.contents[191] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -2215,9 +1578,7 @@ public void test1() throws Throwable { } value = msg.contents[192]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[192] + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.contents[192] + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -2225,9 +1586,7 @@ public void test1() throws Throwable { } value = msg.contents[193]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[193] + "' != '" + 206 + "'", - value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.contents[193] + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; @@ -2235,9 +1594,7 @@ public void test1() throws Throwable { } value = msg.contents[194]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[194] + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.contents[194] + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -2245,9 +1602,7 @@ public void test1() throws Throwable { } value = msg.contents[195]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[195] + "' != '" + 211 + "'", - value.equals(BigInteger.valueOf(211L))); + org.junit.Assert.assertTrue("'" + msg.contents[195] + "' != '" + 211 + "'", value.equals(BigInteger.valueOf( 211L ) ) ); } else { value = value.longValue(); expected = 211L; @@ -2255,9 +1610,7 @@ public void test1() throws Throwable { } value = msg.contents[196]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[196] + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.contents[196] + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -2265,9 +1618,7 @@ public void test1() throws Throwable { } value = msg.contents[197]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[197] + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.contents[197] + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -2275,9 +1626,7 @@ public void test1() throws Throwable { } value = msg.contents[198]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[198] + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.contents[198] + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -2285,9 +1634,7 @@ public void test1() throws Throwable { } value = msg.contents[199]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[199] + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.contents[199] + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -2295,9 +1642,7 @@ public void test1() throws Throwable { } value = msg.contents[200]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[200] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.contents[200] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -2305,9 +1650,7 @@ public void test1() throws Throwable { } value = msg.contents[201]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[201] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.contents[201] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -2315,9 +1658,7 @@ public void test1() throws Throwable { } value = msg.contents[202]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[202] + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.contents[202] + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -2325,9 +1666,7 @@ public void test1() throws Throwable { } value = msg.contents[203]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[203] + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.contents[203] + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -2335,9 +1674,7 @@ public void test1() throws Throwable { } value = msg.contents[204]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[204] + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.contents[204] + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -2345,9 +1682,7 @@ public void test1() throws Throwable { } value = msg.contents[205]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[205] + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.contents[205] + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -2355,9 +1690,7 @@ public void test1() throws Throwable { } value = msg.contents[206]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[206] + "' != '" + 244 + "'", - value.equals(BigInteger.valueOf(244L))); + org.junit.Assert.assertTrue("'" + msg.contents[206] + "' != '" + 244 + "'", value.equals(BigInteger.valueOf( 244L ) ) ); } else { value = value.longValue(); expected = 244L; @@ -2365,9 +1698,7 @@ public void test1() throws Throwable { } value = msg.contents[207]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[207] + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.contents[207] + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -2375,9 +1706,7 @@ public void test1() throws Throwable { } value = msg.contents[208]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[208] + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.contents[208] + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -2385,9 +1714,7 @@ public void test1() throws Throwable { } value = msg.contents[209]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[209] + "' != '" + 199 + "'", - value.equals(BigInteger.valueOf(199L))); + org.junit.Assert.assertTrue("'" + msg.contents[209] + "' != '" + 199 + "'", value.equals(BigInteger.valueOf( 199L ) ) ); } else { value = value.longValue(); expected = 199L; @@ -2395,9 +1722,7 @@ public void test1() throws Throwable { } value = msg.contents[210]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[210] + "' != '" + 241 + "'", - value.equals(BigInteger.valueOf(241L))); + org.junit.Assert.assertTrue("'" + msg.contents[210] + "' != '" + 241 + "'", value.equals(BigInteger.valueOf( 241L ) ) ); } else { value = value.longValue(); expected = 241L; @@ -2405,9 +1730,7 @@ public void test1() throws Throwable { } value = msg.contents[211]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[211] + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.contents[211] + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -2415,9 +1738,7 @@ public void test1() throws Throwable { } value = msg.contents[212]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[212] + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.contents[212] + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -2425,9 +1746,7 @@ public void test1() throws Throwable { } value = msg.contents[213]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[213] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.contents[213] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -2435,9 +1754,7 @@ public void test1() throws Throwable { } value = msg.contents[214]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[214] + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.contents[214] + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -2445,9 +1762,7 @@ public void test1() throws Throwable { } value = msg.contents[215]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[215] + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.contents[215] + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -2455,9 +1770,7 @@ public void test1() throws Throwable { } value = msg.contents[216]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[216] + "' != '" + 125 + "'", - value.equals(BigInteger.valueOf(125L))); + org.junit.Assert.assertTrue("'" + msg.contents[216] + "' != '" + 125 + "'", value.equals(BigInteger.valueOf( 125L ) ) ); } else { value = value.longValue(); expected = 125L; @@ -2465,9 +1778,7 @@ public void test1() throws Throwable { } value = msg.contents[217]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[217] + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.contents[217] + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -2475,9 +1786,7 @@ public void test1() throws Throwable { } value = msg.contents[218]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[218] + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.contents[218] + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -2485,9 +1794,7 @@ public void test1() throws Throwable { } value = msg.contents[219]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[219] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.contents[219] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -2495,9 +1802,7 @@ public void test1() throws Throwable { } value = msg.contents[220]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[220] + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.contents[220] + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -2505,9 +1810,7 @@ public void test1() throws Throwable { } value = msg.contents[221]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[221] + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.contents[221] + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -2515,9 +1818,7 @@ public void test1() throws Throwable { } value = msg.contents[222]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[222] + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.contents[222] + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -2525,9 +1826,7 @@ public void test1() throws Throwable { } value = msg.contents[223]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[223] + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.contents[223] + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -2535,9 +1834,7 @@ public void test1() throws Throwable { } value = msg.contents[224]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[224] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.contents[224] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -2545,9 +1842,7 @@ public void test1() throws Throwable { } value = msg.contents[225]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[225] + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.contents[225] + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -2555,9 +1850,7 @@ public void test1() throws Throwable { } value = msg.contents[226]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[226] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.contents[226] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -2565,9 +1858,7 @@ public void test1() throws Throwable { } value = msg.contents[227]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[227] + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.contents[227] + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -2575,9 +1866,7 @@ public void test1() throws Throwable { } value = msg.contents[228]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[228] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.contents[228] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -2585,9 +1874,7 @@ public void test1() throws Throwable { } value = msg.contents[229]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[229] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.contents[229] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -2595,9 +1882,7 @@ public void test1() throws Throwable { } value = msg.contents[230]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[230] + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.contents[230] + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -2605,9 +1890,7 @@ public void test1() throws Throwable { } value = msg.contents[231]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[231] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.contents[231] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -2615,9 +1898,7 @@ public void test1() throws Throwable { } value = msg.contents[232]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[232] + "' != '" + 74 + "'", - value.equals(BigInteger.valueOf(74L))); + org.junit.Assert.assertTrue("'" + msg.contents[232] + "' != '" + 74 + "'", value.equals(BigInteger.valueOf( 74L ) ) ); } else { value = value.longValue(); expected = 74L; @@ -2625,9 +1906,7 @@ public void test1() throws Throwable { } value = msg.contents[233]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[233] + "' != '" + 223 + "'", - value.equals(BigInteger.valueOf(223L))); + org.junit.Assert.assertTrue("'" + msg.contents[233] + "' != '" + 223 + "'", value.equals(BigInteger.valueOf( 223L ) ) ); } else { value = value.longValue(); expected = 223L; @@ -2635,9 +1914,7 @@ public void test1() throws Throwable { } value = msg.contents[234]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[234] + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.contents[234] + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -2645,9 +1922,7 @@ public void test1() throws Throwable { } value = msg.contents[235]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[235] + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.contents[235] + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -2655,9 +1930,7 @@ public void test1() throws Throwable { } value = msg.contents[236]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[236] + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.contents[236] + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -2665,9 +1938,7 @@ public void test1() throws Throwable { } value = msg.contents[237]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[237] + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.contents[237] + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -2675,9 +1946,7 @@ public void test1() throws Throwable { } value = msg.contents[238]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[238] + "' != '" + 167 + "'", - value.equals(BigInteger.valueOf(167L))); + org.junit.Assert.assertTrue("'" + msg.contents[238] + "' != '" + 167 + "'", value.equals(BigInteger.valueOf( 167L ) ) ); } else { value = value.longValue(); expected = 167L; @@ -2685,9 +1954,7 @@ public void test1() throws Throwable { } value = msg.contents[239]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[239] + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.contents[239] + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -2695,9 +1962,7 @@ public void test1() throws Throwable { } value = msg.contents[240]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[240] + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.contents[240] + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -2705,9 +1970,7 @@ public void test1() throws Throwable { } value = msg.contents[241]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[241] + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.contents[241] + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -2715,9 +1978,7 @@ public void test1() throws Throwable { } value = msg.contents[242]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[242] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.contents[242] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -2725,9 +1986,7 @@ public void test1() throws Throwable { } value = msg.contents[243]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[243] + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.contents[243] + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -2735,9 +1994,7 @@ public void test1() throws Throwable { } value = msg.contents[244]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[244] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.contents[244] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -2745,9 +2002,7 @@ public void test1() throws Throwable { } value = msg.contents[245]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[245] + "' != '" + 236 + "'", - value.equals(BigInteger.valueOf(236L))); + org.junit.Assert.assertTrue("'" + msg.contents[245] + "' != '" + 236 + "'", value.equals(BigInteger.valueOf( 236L ) ) ); } else { value = value.longValue(); expected = 236L; @@ -2755,9 +2010,7 @@ public void test1() throws Throwable { } value = msg.contents[246]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[246] + "' != '" + 234 + "'", - value.equals(BigInteger.valueOf(234L))); + org.junit.Assert.assertTrue("'" + msg.contents[246] + "' != '" + 234 + "'", value.equals(BigInteger.valueOf( 234L ) ) ); } else { value = value.longValue(); expected = 234L; @@ -2765,9 +2018,7 @@ public void test1() throws Throwable { } value = msg.contents[247]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[247] + "' != '" + 196 + "'", - value.equals(BigInteger.valueOf(196L))); + org.junit.Assert.assertTrue("'" + msg.contents[247] + "' != '" + 196 + "'", value.equals(BigInteger.valueOf( 196L ) ) ); } else { value = value.longValue(); expected = 196L; @@ -2775,9 +2026,7 @@ public void test1() throws Throwable { } value = msg.contents[248]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[248] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.contents[248] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -2785,9 +2034,7 @@ public void test1() throws Throwable { } value = msg.contents[249]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[249] + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.contents[249] + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -2795,9 +2042,7 @@ public void test1() throws Throwable { } value = msg.contents[250]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[250] + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.contents[250] + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -2805,9 +2050,7 @@ public void test1() throws Throwable { } value = msg.sequence; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sequence + "' != '" + 259241795 + "'", - value.equals(BigInteger.valueOf(259241795L))); + org.junit.Assert.assertTrue("'" + msg.sequence + "' != '" + 259241795 + "'", value.equals(BigInteger.valueOf( 259241795L ) ) ); } else { value = value.longValue(); expected = 259241795L; diff --git a/java/test/auto_check_sbp_file_io_MsgFileioRemoveTest.java b/java/test/auto_check_sbp_file_io_MsgFileioRemoveTest.java index 4ada7fe2ebcafd52863cb747825af072df14da4e..8bfacad036d5712cfc4fc17ef4a9a296d515bf80 100644 GIT binary patch delta 312 zcmdnZ+r`VGuf?S>kx_!taHG@_#>saXTPCM4Y075i7UUO|C}bs;CFLOK167e%oms+lnR9TW59jj2S0b*#HnCn0ohK5E^mL)>S3?^w{0%ako zhf5k7Vn`am3^Oz^g_|K_0cXN=80bt6X4PR-m|V{)3M8knnzAYsClx46KEpZ>$j@R6 F1OP_qU19(L delta 397 zcmeC;-OVeduchFeUr_Q@9dC0}CWJLaPC$CAHQddnc=~s)`y^7?>m*>nIphBqr-96eL#W Y0?#Jd1VSWJ|U{0C8PqBme*a diff --git a/java/test/auto_check_sbp_file_io_MsgFileioWriteRespTest.java b/java/test/auto_check_sbp_file_io_MsgFileioWriteRespTest.java index 9ac184115..1ca152dd6 100644 --- a/java/test/auto_check_sbp_file_io_MsgFileioWriteRespTest.java +++ b/java/test/auto_check_sbp_file_io_MsgFileioWriteRespTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/file_io/test_MsgFileioWriteResp.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/file_io/test_MsgFileioWriteResp.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.file_io.MsgFileioWriteResp; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_file_io_MsgFileioWriteRespTest { @@ -30,20 +34,15 @@ public class auto_check_sbp_file_io_MsgFileioWriteRespTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_file_io_MsgFileioWriteRespTest.test1"); - byte[] payload = - new byte[] { - (byte) 202, (byte) 0, (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xab, payload); - MsgFileioWriteResp msg = new MsgFileioWriteResp(sbp); + byte[] payload = new byte[] {(byte)202,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xab, payload ); + MsgFileioWriteResp msg = new MsgFileioWriteResp( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.sequence; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sequence + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.sequence + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; diff --git a/java/test/auto_check_sbp_flash_MsgFlashDoneTest.java b/java/test/auto_check_sbp_flash_MsgFlashDoneTest.java index 694b46df8..252298d3c 100644 --- a/java/test/auto_check_sbp_flash_MsgFlashDoneTest.java +++ b/java/test/auto_check_sbp_flash_MsgFlashDoneTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgFlashDone.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgFlashDone.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.flash.MsgFlashDone; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_flash_MsgFlashDoneTest { @@ -27,21 +32,17 @@ public class auto_check_sbp_flash_MsgFlashDoneTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_flash_MsgFlashDoneTest.test1"); - byte[] payload = - new byte[] { - (byte) 82, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0xe0, payload); - MsgFlashDone msg = new MsgFlashDone(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_flash_MsgFlashDoneTest.test1"); + byte[] payload = new byte[] {(byte)82, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0xe0, payload ); + MsgFlashDone msg = new MsgFlashDone( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.response; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.response + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.response + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; diff --git a/java/test/auto_check_sbp_flash_MsgFlashEraseTest.java b/java/test/auto_check_sbp_flash_MsgFlashEraseTest.java index bd3c2a580..a4990fd84 100644 --- a/java/test/auto_check_sbp_flash_MsgFlashEraseTest.java +++ b/java/test/auto_check_sbp_flash_MsgFlashEraseTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgFlashErase.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgFlashErase.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.flash.MsgFlashErase; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_flash_MsgFlashEraseTest { @@ -27,21 +32,17 @@ public class auto_check_sbp_flash_MsgFlashEraseTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_flash_MsgFlashEraseTest.test1"); - byte[] payload = - new byte[] { - (byte) 74, (byte) 238, (byte) 177, (byte) 118, (byte) 132, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0xe2, payload); - MsgFlashErase msg = new MsgFlashErase(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_flash_MsgFlashEraseTest.test1"); + byte[] payload = new byte[] {(byte)74,(byte)238,(byte)177,(byte)118,(byte)132, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0xe2, payload ); + MsgFlashErase msg = new MsgFlashErase( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.sector_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sector_num + "' != '" + 2222371310L + "'", - value.equals(new BigInteger("2222371310"))); + org.junit.Assert.assertTrue("'" + msg.sector_num + "' != '" + 2222371310L + "'", value.equals( new BigInteger( "2222371310" ) ) ); } else { value = value.longValue(); expected = 2222371310L; @@ -49,8 +50,7 @@ public void test1() throws Throwable { } value = msg.target; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.target + "' != '" + 74 + "'", value.equals(BigInteger.valueOf(74L))); + org.junit.Assert.assertTrue("'" + msg.target + "' != '" + 74 + "'", value.equals(BigInteger.valueOf( 74L ) ) ); } else { value = value.longValue(); expected = 74L; diff --git a/java/test/auto_check_sbp_flash_MsgFlashProgramTest.java b/java/test/auto_check_sbp_flash_MsgFlashProgramTest.java index c9e442072..7b770d214 100644 --- a/java/test/auto_check_sbp_flash_MsgFlashProgramTest.java +++ b/java/test/auto_check_sbp_flash_MsgFlashProgramTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgFlashProgram.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgFlashProgram.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.flash.MsgFlashProgram; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_flash_MsgFlashProgramTest { @@ -27,275 +32,17 @@ public class auto_check_sbp_flash_MsgFlashProgramTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_flash_MsgFlashProgramTest.test1"); - byte[] payload = - new byte[] { - (byte) 212, - (byte) 87, - (byte) 52, - (byte) 244, - (byte) 250, - (byte) 176, - (byte) 222, - (byte) 235, - (byte) 106, - (byte) 144, - (byte) 29, - (byte) 141, - (byte) 255, - (byte) 3, - (byte) 16, - (byte) 192, - (byte) 237, - (byte) 172, - (byte) 254, - (byte) 213, - (byte) 4, - (byte) 220, - (byte) 98, - (byte) 34, - (byte) 222, - (byte) 230, - (byte) 214, - (byte) 6, - (byte) 217, - (byte) 172, - (byte) 122, - (byte) 46, - (byte) 13, - (byte) 38, - (byte) 240, - (byte) 236, - (byte) 60, - (byte) 121, - (byte) 47, - (byte) 252, - (byte) 163, - (byte) 141, - (byte) 222, - (byte) 29, - (byte) 168, - (byte) 214, - (byte) 118, - (byte) 55, - (byte) 201, - (byte) 233, - (byte) 21, - (byte) 214, - (byte) 57, - (byte) 245, - (byte) 246, - (byte) 19, - (byte) 3, - (byte) 121, - (byte) 49, - (byte) 231, - (byte) 37, - (byte) 186, - (byte) 58, - (byte) 238, - (byte) 98, - (byte) 39, - (byte) 70, - (byte) 232, - (byte) 133, - (byte) 25, - (byte) 10, - (byte) 134, - (byte) 129, - (byte) 69, - (byte) 228, - (byte) 134, - (byte) 9, - (byte) 88, - (byte) 183, - (byte) 133, - (byte) 171, - (byte) 255, - (byte) 166, - (byte) 100, - (byte) 152, - (byte) 231, - (byte) 92, - (byte) 9, - (byte) 196, - (byte) 106, - (byte) 246, - (byte) 29, - (byte) 145, - (byte) 156, - (byte) 151, - (byte) 32, - (byte) 67, - (byte) 188, - (byte) 63, - (byte) 233, - (byte) 142, - (byte) 174, - (byte) 139, - (byte) 154, - (byte) 127, - (byte) 35, - (byte) 60, - (byte) 56, - (byte) 187, - (byte) 121, - (byte) 103, - (byte) 135, - (byte) 152, - (byte) 182, - (byte) 88, - (byte) 160, - (byte) 255, - (byte) 227, - (byte) 240, - (byte) 54, - (byte) 100, - (byte) 91, - (byte) 31, - (byte) 141, - (byte) 102, - (byte) 130, - (byte) 254, - (byte) 54, - (byte) 227, - (byte) 229, - (byte) 62, - (byte) 53, - (byte) 225, - (byte) 143, - (byte) 88, - (byte) 139, - (byte) 126, - (byte) 235, - (byte) 235, - (byte) 35, - (byte) 54, - (byte) 134, - (byte) 163, - (byte) 92, - (byte) 57, - (byte) 87, - (byte) 130, - (byte) 178, - (byte) 22, - (byte) 158, - (byte) 18, - (byte) 237, - (byte) 209, - (byte) 187, - (byte) 226, - (byte) 1, - (byte) 46, - (byte) 64, - (byte) 226, - (byte) 235, - (byte) 213, - (byte) 186, - (byte) 159, - (byte) 221, - (byte) 186, - (byte) 25, - (byte) 115, - (byte) 84, - (byte) 131, - (byte) 167, - (byte) 201, - (byte) 104, - (byte) 1, - (byte) 200, - (byte) 13, - (byte) 50, - (byte) 71, - (byte) 73, - (byte) 193, - (byte) 201, - (byte) 250, - (byte) 172, - (byte) 193, - (byte) 13, - (byte) 20, - (byte) 238, - (byte) 130, - (byte) 243, - (byte) 68, - (byte) 4, - (byte) 72, - (byte) 46, - (byte) 194, - (byte) 113, - (byte) 255, - (byte) 238, - (byte) 15, - (byte) 230, - (byte) 64, - (byte) 178, - (byte) 127, - (byte) 217, - (byte) 92, - (byte) 160, - (byte) 201, - (byte) 118, - (byte) 163, - (byte) 144, - (byte) 58, - (byte) 28, - (byte) 174, - (byte) 65, - (byte) 73, - (byte) 45, - (byte) 123, - (byte) 118, - (byte) 83, - (byte) 107, - (byte) 239, - (byte) 168, - (byte) 32, - (byte) 212, - (byte) 191, - (byte) 81, - (byte) 93, - (byte) 186, - (byte) 223, - (byte) 32, - (byte) 19, - (byte) 58, - (byte) 137, - (byte) 72, - (byte) 217, - (byte) 151, - (byte) 251, - (byte) 83, - (byte) 20, - (byte) 113, - (byte) 37, - (byte) 151, - (byte) 34, - (byte) 37, - (byte) 71, - (byte) 95, - (byte) 105, - (byte) 235, - (byte) 144, - (byte) 164, - (byte) 83, - (byte) 197, - (byte) 254, - (byte) 183, - (byte) 223, - (byte) 91, - (byte) 19, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0xe6, payload); - MsgFlashProgram msg = new MsgFlashProgram(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_flash_MsgFlashProgramTest.test1"); + byte[] payload = new byte[] {(byte)212,(byte)87,(byte)52,(byte)244,(byte)250,(byte)176,(byte)222,(byte)235,(byte)106,(byte)144,(byte)29,(byte)141,(byte)255,(byte)3,(byte)16,(byte)192,(byte)237,(byte)172,(byte)254,(byte)213,(byte)4,(byte)220,(byte)98,(byte)34,(byte)222,(byte)230,(byte)214,(byte)6,(byte)217,(byte)172,(byte)122,(byte)46,(byte)13,(byte)38,(byte)240,(byte)236,(byte)60,(byte)121,(byte)47,(byte)252,(byte)163,(byte)141,(byte)222,(byte)29,(byte)168,(byte)214,(byte)118,(byte)55,(byte)201,(byte)233,(byte)21,(byte)214,(byte)57,(byte)245,(byte)246,(byte)19,(byte)3,(byte)121,(byte)49,(byte)231,(byte)37,(byte)186,(byte)58,(byte)238,(byte)98,(byte)39,(byte)70,(byte)232,(byte)133,(byte)25,(byte)10,(byte)134,(byte)129,(byte)69,(byte)228,(byte)134,(byte)9,(byte)88,(byte)183,(byte)133,(byte)171,(byte)255,(byte)166,(byte)100,(byte)152,(byte)231,(byte)92,(byte)9,(byte)196,(byte)106,(byte)246,(byte)29,(byte)145,(byte)156,(byte)151,(byte)32,(byte)67,(byte)188,(byte)63,(byte)233,(byte)142,(byte)174,(byte)139,(byte)154,(byte)127,(byte)35,(byte)60,(byte)56,(byte)187,(byte)121,(byte)103,(byte)135,(byte)152,(byte)182,(byte)88,(byte)160,(byte)255,(byte)227,(byte)240,(byte)54,(byte)100,(byte)91,(byte)31,(byte)141,(byte)102,(byte)130,(byte)254,(byte)54,(byte)227,(byte)229,(byte)62,(byte)53,(byte)225,(byte)143,(byte)88,(byte)139,(byte)126,(byte)235,(byte)235,(byte)35,(byte)54,(byte)134,(byte)163,(byte)92,(byte)57,(byte)87,(byte)130,(byte)178,(byte)22,(byte)158,(byte)18,(byte)237,(byte)209,(byte)187,(byte)226,(byte)1,(byte)46,(byte)64,(byte)226,(byte)235,(byte)213,(byte)186,(byte)159,(byte)221,(byte)186,(byte)25,(byte)115,(byte)84,(byte)131,(byte)167,(byte)201,(byte)104,(byte)1,(byte)200,(byte)13,(byte)50,(byte)71,(byte)73,(byte)193,(byte)201,(byte)250,(byte)172,(byte)193,(byte)13,(byte)20,(byte)238,(byte)130,(byte)243,(byte)68,(byte)4,(byte)72,(byte)46,(byte)194,(byte)113,(byte)255,(byte)238,(byte)15,(byte)230,(byte)64,(byte)178,(byte)127,(byte)217,(byte)92,(byte)160,(byte)201,(byte)118,(byte)163,(byte)144,(byte)58,(byte)28,(byte)174,(byte)65,(byte)73,(byte)45,(byte)123,(byte)118,(byte)83,(byte)107,(byte)239,(byte)168,(byte)32,(byte)212,(byte)191,(byte)81,(byte)93,(byte)186,(byte)223,(byte)32,(byte)19,(byte)58,(byte)137,(byte)72,(byte)217,(byte)151,(byte)251,(byte)83,(byte)20,(byte)113,(byte)37,(byte)151,(byte)34,(byte)37,(byte)71,(byte)95,(byte)105,(byte)235,(byte)144,(byte)164,(byte)83,(byte)197,(byte)254,(byte)183,(byte)223,(byte)91,(byte)19, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0xe6, payload ); + MsgFlashProgram msg = new MsgFlashProgram( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.addr_len; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.addr_len + "' != '" + 250 + "'", - value.equals(BigInteger.valueOf(250L))); + org.junit.Assert.assertTrue("'" + msg.addr_len + "' != '" + 250 + "'", value.equals(BigInteger.valueOf( 250L ) ) ); } else { value = value.longValue(); expected = 250L; @@ -303,9 +50,7 @@ public void test1() throws Throwable { } value = msg.addr_start[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.addr_start[0] + "' != '" + 87 + "'", - value.equals(BigInteger.valueOf(87L))); + org.junit.Assert.assertTrue("'" + msg.addr_start[0] + "' != '" + 87 + "'", value.equals(BigInteger.valueOf( 87L ) ) ); } else { value = value.longValue(); expected = 87L; @@ -313,9 +58,7 @@ public void test1() throws Throwable { } value = msg.addr_start[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.addr_start[1] + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.addr_start[1] + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -323,9 +66,7 @@ public void test1() throws Throwable { } value = msg.addr_start[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.addr_start[2] + "' != '" + 244 + "'", - value.equals(BigInteger.valueOf(244L))); + org.junit.Assert.assertTrue("'" + msg.addr_start[2] + "' != '" + 244 + "'", value.equals(BigInteger.valueOf( 244L ) ) ); } else { value = value.longValue(); expected = 244L; @@ -333,9 +74,7 @@ public void test1() throws Throwable { } value = msg.data[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[0] + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.data[0] + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -343,9 +82,7 @@ public void test1() throws Throwable { } value = msg.data[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[1] + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.data[1] + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -353,9 +90,7 @@ public void test1() throws Throwable { } value = msg.data[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[2] + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.data[2] + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -363,9 +98,7 @@ public void test1() throws Throwable { } value = msg.data[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[3] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.data[3] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -373,9 +106,7 @@ public void test1() throws Throwable { } value = msg.data[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[4] + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.data[4] + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -383,8 +114,7 @@ public void test1() throws Throwable { } value = msg.data[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[5] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.data[5] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -392,9 +122,7 @@ public void test1() throws Throwable { } value = msg.data[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[6] + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.data[6] + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -402,9 +130,7 @@ public void test1() throws Throwable { } value = msg.data[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[7] + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.data[7] + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -412,8 +138,7 @@ public void test1() throws Throwable { } value = msg.data[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[8] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.data[8] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -421,8 +146,7 @@ public void test1() throws Throwable { } value = msg.data[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[9] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.data[9] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -430,9 +154,7 @@ public void test1() throws Throwable { } value = msg.data[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[10] + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.data[10] + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -440,9 +162,7 @@ public void test1() throws Throwable { } value = msg.data[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[11] + "' != '" + 237 + "'", - value.equals(BigInteger.valueOf(237L))); + org.junit.Assert.assertTrue("'" + msg.data[11] + "' != '" + 237 + "'", value.equals(BigInteger.valueOf( 237L ) ) ); } else { value = value.longValue(); expected = 237L; @@ -450,9 +170,7 @@ public void test1() throws Throwable { } value = msg.data[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[12] + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.data[12] + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -460,9 +178,7 @@ public void test1() throws Throwable { } value = msg.data[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[13] + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.data[13] + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -470,9 +186,7 @@ public void test1() throws Throwable { } value = msg.data[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[14] + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.data[14] + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -480,8 +194,7 @@ public void test1() throws Throwable { } value = msg.data[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[15] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.data[15] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -489,9 +202,7 @@ public void test1() throws Throwable { } value = msg.data[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[16] + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.data[16] + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -499,9 +210,7 @@ public void test1() throws Throwable { } value = msg.data[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[17] + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.data[17] + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -509,9 +218,7 @@ public void test1() throws Throwable { } value = msg.data[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[18] + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.data[18] + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -519,9 +226,7 @@ public void test1() throws Throwable { } value = msg.data[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[19] + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.data[19] + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -529,9 +234,7 @@ public void test1() throws Throwable { } value = msg.data[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[20] + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.data[20] + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -539,9 +242,7 @@ public void test1() throws Throwable { } value = msg.data[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[21] + "' != '" + 214 + "'", - value.equals(BigInteger.valueOf(214L))); + org.junit.Assert.assertTrue("'" + msg.data[21] + "' != '" + 214 + "'", value.equals(BigInteger.valueOf( 214L ) ) ); } else { value = value.longValue(); expected = 214L; @@ -549,8 +250,7 @@ public void test1() throws Throwable { } value = msg.data[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[22] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.data[22] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -558,9 +258,7 @@ public void test1() throws Throwable { } value = msg.data[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[23] + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.data[23] + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -568,9 +266,7 @@ public void test1() throws Throwable { } value = msg.data[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[24] + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.data[24] + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -578,9 +274,7 @@ public void test1() throws Throwable { } value = msg.data[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[25] + "' != '" + 122 + "'", - value.equals(BigInteger.valueOf(122L))); + org.junit.Assert.assertTrue("'" + msg.data[25] + "' != '" + 122 + "'", value.equals(BigInteger.valueOf( 122L ) ) ); } else { value = value.longValue(); expected = 122L; @@ -588,9 +282,7 @@ public void test1() throws Throwable { } value = msg.data[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[26] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.data[26] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -598,9 +290,7 @@ public void test1() throws Throwable { } value = msg.data[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[27] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.data[27] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -608,9 +298,7 @@ public void test1() throws Throwable { } value = msg.data[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[28] + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.data[28] + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -618,9 +306,7 @@ public void test1() throws Throwable { } value = msg.data[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[29] + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.data[29] + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -628,9 +314,7 @@ public void test1() throws Throwable { } value = msg.data[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[30] + "' != '" + 236 + "'", - value.equals(BigInteger.valueOf(236L))); + org.junit.Assert.assertTrue("'" + msg.data[30] + "' != '" + 236 + "'", value.equals(BigInteger.valueOf( 236L ) ) ); } else { value = value.longValue(); expected = 236L; @@ -638,9 +322,7 @@ public void test1() throws Throwable { } value = msg.data[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[31] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.data[31] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -648,9 +330,7 @@ public void test1() throws Throwable { } value = msg.data[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[32] + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.data[32] + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -658,9 +338,7 @@ public void test1() throws Throwable { } value = msg.data[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[33] + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.data[33] + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -668,9 +346,7 @@ public void test1() throws Throwable { } value = msg.data[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[34] + "' != '" + 252 + "'", - value.equals(BigInteger.valueOf(252L))); + org.junit.Assert.assertTrue("'" + msg.data[34] + "' != '" + 252 + "'", value.equals(BigInteger.valueOf( 252L ) ) ); } else { value = value.longValue(); expected = 252L; @@ -678,9 +354,7 @@ public void test1() throws Throwable { } value = msg.data[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[35] + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.data[35] + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -688,9 +362,7 @@ public void test1() throws Throwable { } value = msg.data[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[36] + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.data[36] + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -698,9 +370,7 @@ public void test1() throws Throwable { } value = msg.data[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[37] + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.data[37] + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -708,9 +378,7 @@ public void test1() throws Throwable { } value = msg.data[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[38] + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.data[38] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -718,9 +386,7 @@ public void test1() throws Throwable { } value = msg.data[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[39] + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.data[39] + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -728,9 +394,7 @@ public void test1() throws Throwable { } value = msg.data[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[40] + "' != '" + 214 + "'", - value.equals(BigInteger.valueOf(214L))); + org.junit.Assert.assertTrue("'" + msg.data[40] + "' != '" + 214 + "'", value.equals(BigInteger.valueOf( 214L ) ) ); } else { value = value.longValue(); expected = 214L; @@ -738,9 +402,7 @@ public void test1() throws Throwable { } value = msg.data[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[41] + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.data[41] + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -748,9 +410,7 @@ public void test1() throws Throwable { } value = msg.data[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[42] + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.data[42] + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -758,9 +418,7 @@ public void test1() throws Throwable { } value = msg.data[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[43] + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.data[43] + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -768,9 +426,7 @@ public void test1() throws Throwable { } value = msg.data[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[44] + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.data[44] + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -778,9 +434,7 @@ public void test1() throws Throwable { } value = msg.data[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[45] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.data[45] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -788,9 +442,7 @@ public void test1() throws Throwable { } value = msg.data[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[46] + "' != '" + 214 + "'", - value.equals(BigInteger.valueOf(214L))); + org.junit.Assert.assertTrue("'" + msg.data[46] + "' != '" + 214 + "'", value.equals(BigInteger.valueOf( 214L ) ) ); } else { value = value.longValue(); expected = 214L; @@ -798,9 +450,7 @@ public void test1() throws Throwable { } value = msg.data[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[47] + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.data[47] + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -808,9 +458,7 @@ public void test1() throws Throwable { } value = msg.data[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[48] + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.data[48] + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -818,9 +466,7 @@ public void test1() throws Throwable { } value = msg.data[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[49] + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.data[49] + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -828,9 +474,7 @@ public void test1() throws Throwable { } value = msg.data[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[50] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.data[50] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -838,8 +482,7 @@ public void test1() throws Throwable { } value = msg.data[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[51] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.data[51] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -847,9 +490,7 @@ public void test1() throws Throwable { } value = msg.data[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[52] + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.data[52] + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -857,9 +498,7 @@ public void test1() throws Throwable { } value = msg.data[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[53] + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.data[53] + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -867,9 +506,7 @@ public void test1() throws Throwable { } value = msg.data[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[54] + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.data[54] + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -877,9 +514,7 @@ public void test1() throws Throwable { } value = msg.data[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[55] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.data[55] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -887,9 +522,7 @@ public void test1() throws Throwable { } value = msg.data[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[56] + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.data[56] + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -897,9 +530,7 @@ public void test1() throws Throwable { } value = msg.data[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[57] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.data[57] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -907,9 +538,7 @@ public void test1() throws Throwable { } value = msg.data[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[58] + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.data[58] + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -917,9 +546,7 @@ public void test1() throws Throwable { } value = msg.data[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[59] + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.data[59] + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -927,9 +554,7 @@ public void test1() throws Throwable { } value = msg.data[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[60] + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.data[60] + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -937,9 +562,7 @@ public void test1() throws Throwable { } value = msg.data[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[61] + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.data[61] + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -947,9 +570,7 @@ public void test1() throws Throwable { } value = msg.data[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[62] + "' != '" + 232 + "'", - value.equals(BigInteger.valueOf(232L))); + org.junit.Assert.assertTrue("'" + msg.data[62] + "' != '" + 232 + "'", value.equals(BigInteger.valueOf( 232L ) ) ); } else { value = value.longValue(); expected = 232L; @@ -957,9 +578,7 @@ public void test1() throws Throwable { } value = msg.data[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[63] + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.data[63] + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -967,9 +586,7 @@ public void test1() throws Throwable { } value = msg.data[64]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[64] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.data[64] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -977,9 +594,7 @@ public void test1() throws Throwable { } value = msg.data[65]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[65] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.data[65] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -987,9 +602,7 @@ public void test1() throws Throwable { } value = msg.data[66]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[66] + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.data[66] + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -997,9 +610,7 @@ public void test1() throws Throwable { } value = msg.data[67]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[67] + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.data[67] + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -1007,9 +618,7 @@ public void test1() throws Throwable { } value = msg.data[68]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[68] + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.data[68] + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -1017,9 +626,7 @@ public void test1() throws Throwable { } value = msg.data[69]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[69] + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.data[69] + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -1027,9 +634,7 @@ public void test1() throws Throwable { } value = msg.data[70]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[70] + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.data[70] + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -1037,8 +642,7 @@ public void test1() throws Throwable { } value = msg.data[71]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[71] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.data[71] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -1046,9 +650,7 @@ public void test1() throws Throwable { } value = msg.data[72]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[72] + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.data[72] + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -1056,9 +658,7 @@ public void test1() throws Throwable { } value = msg.data[73]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[73] + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.data[73] + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -1066,9 +666,7 @@ public void test1() throws Throwable { } value = msg.data[74]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[74] + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.data[74] + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -1076,9 +674,7 @@ public void test1() throws Throwable { } value = msg.data[75]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[75] + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.data[75] + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -1086,9 +682,7 @@ public void test1() throws Throwable { } value = msg.data[76]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[76] + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.data[76] + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -1096,9 +690,7 @@ public void test1() throws Throwable { } value = msg.data[77]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[77] + "' != '" + 166 + "'", - value.equals(BigInteger.valueOf(166L))); + org.junit.Assert.assertTrue("'" + msg.data[77] + "' != '" + 166 + "'", value.equals(BigInteger.valueOf( 166L ) ) ); } else { value = value.longValue(); expected = 166L; @@ -1106,9 +698,7 @@ public void test1() throws Throwable { } value = msg.data[78]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[78] + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.data[78] + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -1116,9 +706,7 @@ public void test1() throws Throwable { } value = msg.data[79]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[79] + "' != '" + 152 + "'", - value.equals(BigInteger.valueOf(152L))); + org.junit.Assert.assertTrue("'" + msg.data[79] + "' != '" + 152 + "'", value.equals(BigInteger.valueOf( 152L ) ) ); } else { value = value.longValue(); expected = 152L; @@ -1126,9 +714,7 @@ public void test1() throws Throwable { } value = msg.data[80]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[80] + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.data[80] + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -1136,9 +722,7 @@ public void test1() throws Throwable { } value = msg.data[81]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[81] + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.data[81] + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -1146,8 +730,7 @@ public void test1() throws Throwable { } value = msg.data[82]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[82] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.data[82] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -1155,9 +738,7 @@ public void test1() throws Throwable { } value = msg.data[83]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[83] + "' != '" + 196 + "'", - value.equals(BigInteger.valueOf(196L))); + org.junit.Assert.assertTrue("'" + msg.data[83] + "' != '" + 196 + "'", value.equals(BigInteger.valueOf( 196L ) ) ); } else { value = value.longValue(); expected = 196L; @@ -1165,9 +746,7 @@ public void test1() throws Throwable { } value = msg.data[84]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[84] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.data[84] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -1175,9 +754,7 @@ public void test1() throws Throwable { } value = msg.data[85]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[85] + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.data[85] + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -1185,9 +762,7 @@ public void test1() throws Throwable { } value = msg.data[86]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[86] + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.data[86] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -1195,9 +770,7 @@ public void test1() throws Throwable { } value = msg.data[87]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[87] + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.data[87] + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -1205,9 +778,7 @@ public void test1() throws Throwable { } value = msg.data[88]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[88] + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.data[88] + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -1215,9 +786,7 @@ public void test1() throws Throwable { } value = msg.data[89]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[89] + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.data[89] + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -1225,9 +794,7 @@ public void test1() throws Throwable { } value = msg.data[90]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[90] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.data[90] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -1235,9 +802,7 @@ public void test1() throws Throwable { } value = msg.data[91]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[91] + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.data[91] + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -1245,9 +810,7 @@ public void test1() throws Throwable { } value = msg.data[92]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[92] + "' != '" + 188 + "'", - value.equals(BigInteger.valueOf(188L))); + org.junit.Assert.assertTrue("'" + msg.data[92] + "' != '" + 188 + "'", value.equals(BigInteger.valueOf( 188L ) ) ); } else { value = value.longValue(); expected = 188L; @@ -1255,9 +818,7 @@ public void test1() throws Throwable { } value = msg.data[93]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[93] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.data[93] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -1265,9 +826,7 @@ public void test1() throws Throwable { } value = msg.data[94]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[94] + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.data[94] + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -1275,9 +834,7 @@ public void test1() throws Throwable { } value = msg.data[95]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[95] + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.data[95] + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -1285,9 +842,7 @@ public void test1() throws Throwable { } value = msg.data[96]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[96] + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.data[96] + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -1295,9 +850,7 @@ public void test1() throws Throwable { } value = msg.data[97]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[97] + "' != '" + 139 + "'", - value.equals(BigInteger.valueOf(139L))); + org.junit.Assert.assertTrue("'" + msg.data[97] + "' != '" + 139 + "'", value.equals(BigInteger.valueOf( 139L ) ) ); } else { value = value.longValue(); expected = 139L; @@ -1305,9 +858,7 @@ public void test1() throws Throwable { } value = msg.data[98]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[98] + "' != '" + 154 + "'", - value.equals(BigInteger.valueOf(154L))); + org.junit.Assert.assertTrue("'" + msg.data[98] + "' != '" + 154 + "'", value.equals(BigInteger.valueOf( 154L ) ) ); } else { value = value.longValue(); expected = 154L; @@ -1315,9 +866,7 @@ public void test1() throws Throwable { } value = msg.data[99]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[99] + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.data[99] + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -1325,9 +874,7 @@ public void test1() throws Throwable { } value = msg.data[100]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[100] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.data[100] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -1335,9 +882,7 @@ public void test1() throws Throwable { } value = msg.data[101]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[101] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.data[101] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -1345,9 +890,7 @@ public void test1() throws Throwable { } value = msg.data[102]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[102] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.data[102] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -1355,9 +898,7 @@ public void test1() throws Throwable { } value = msg.data[103]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[103] + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.data[103] + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -1365,9 +906,7 @@ public void test1() throws Throwable { } value = msg.data[104]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[104] + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.data[104] + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -1375,9 +914,7 @@ public void test1() throws Throwable { } value = msg.data[105]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[105] + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.data[105] + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -1385,9 +922,7 @@ public void test1() throws Throwable { } value = msg.data[106]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[106] + "' != '" + 135 + "'", - value.equals(BigInteger.valueOf(135L))); + org.junit.Assert.assertTrue("'" + msg.data[106] + "' != '" + 135 + "'", value.equals(BigInteger.valueOf( 135L ) ) ); } else { value = value.longValue(); expected = 135L; @@ -1395,9 +930,7 @@ public void test1() throws Throwable { } value = msg.data[107]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[107] + "' != '" + 152 + "'", - value.equals(BigInteger.valueOf(152L))); + org.junit.Assert.assertTrue("'" + msg.data[107] + "' != '" + 152 + "'", value.equals(BigInteger.valueOf( 152L ) ) ); } else { value = value.longValue(); expected = 152L; @@ -1405,9 +938,7 @@ public void test1() throws Throwable { } value = msg.data[108]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[108] + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.data[108] + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -1415,9 +946,7 @@ public void test1() throws Throwable { } value = msg.data[109]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[109] + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.data[109] + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -1425,9 +954,7 @@ public void test1() throws Throwable { } value = msg.data[110]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[110] + "' != '" + 160 + "'", - value.equals(BigInteger.valueOf(160L))); + org.junit.Assert.assertTrue("'" + msg.data[110] + "' != '" + 160 + "'", value.equals(BigInteger.valueOf( 160L ) ) ); } else { value = value.longValue(); expected = 160L; @@ -1435,9 +962,7 @@ public void test1() throws Throwable { } value = msg.data[111]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[111] + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.data[111] + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -1445,9 +970,7 @@ public void test1() throws Throwable { } value = msg.data[112]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[112] + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.data[112] + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1455,9 +978,7 @@ public void test1() throws Throwable { } value = msg.data[113]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[113] + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.data[113] + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -1465,9 +986,7 @@ public void test1() throws Throwable { } value = msg.data[114]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[114] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.data[114] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -1475,9 +994,7 @@ public void test1() throws Throwable { } value = msg.data[115]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[115] + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.data[115] + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -1485,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.data[116]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[116] + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.data[116] + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -1495,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.data[117]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[117] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.data[117] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -1505,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.data[118]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[118] + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.data[118] + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -1515,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.data[119]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[119] + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.data[119] + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -1525,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.data[120]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[120] + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.data[120] + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -1535,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.data[121]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[121] + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.data[121] + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -1545,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.data[122]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[122] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.data[122] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -1555,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.data[123]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[123] + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.data[123] + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1565,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.data[124]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[124] + "' != '" + 229 + "'", - value.equals(BigInteger.valueOf(229L))); + org.junit.Assert.assertTrue("'" + msg.data[124] + "' != '" + 229 + "'", value.equals(BigInteger.valueOf( 229L ) ) ); } else { value = value.longValue(); expected = 229L; @@ -1575,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.data[125]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[125] + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.data[125] + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -1585,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.data[126]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[126] + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.data[126] + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -1595,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.data[127]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[127] + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.data[127] + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -1605,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.data[128]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[128] + "' != '" + 143 + "'", - value.equals(BigInteger.valueOf(143L))); + org.junit.Assert.assertTrue("'" + msg.data[128] + "' != '" + 143 + "'", value.equals(BigInteger.valueOf( 143L ) ) ); } else { value = value.longValue(); expected = 143L; @@ -1615,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.data[129]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[129] + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.data[129] + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -1625,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.data[130]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[130] + "' != '" + 139 + "'", - value.equals(BigInteger.valueOf(139L))); + org.junit.Assert.assertTrue("'" + msg.data[130] + "' != '" + 139 + "'", value.equals(BigInteger.valueOf( 139L ) ) ); } else { value = value.longValue(); expected = 139L; @@ -1635,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.data[131]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[131] + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.data[131] + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -1645,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.data[132]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[132] + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.data[132] + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -1655,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.data[133]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[133] + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.data[133] + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -1665,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.data[134]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[134] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.data[134] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -1675,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.data[135]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[135] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.data[135] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -1685,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.data[136]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[136] + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.data[136] + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -1695,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.data[137]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[137] + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.data[137] + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -1705,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.data[138]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[138] + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.data[138] + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -1715,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.data[139]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[139] + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.data[139] + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -1725,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.data[140]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[140] + "' != '" + 87 + "'", - value.equals(BigInteger.valueOf(87L))); + org.junit.Assert.assertTrue("'" + msg.data[140] + "' != '" + 87 + "'", value.equals(BigInteger.valueOf( 87L ) ) ); } else { value = value.longValue(); expected = 87L; @@ -1735,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.data[141]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[141] + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.data[141] + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -1745,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.data[142]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[142] + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.data[142] + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -1755,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.data[143]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[143] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.data[143] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -1765,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.data[144]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[144] + "' != '" + 158 + "'", - value.equals(BigInteger.valueOf(158L))); + org.junit.Assert.assertTrue("'" + msg.data[144] + "' != '" + 158 + "'", value.equals(BigInteger.valueOf( 158L ) ) ); } else { value = value.longValue(); expected = 158L; @@ -1775,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.data[145]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[145] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.data[145] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -1785,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.data[146]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[146] + "' != '" + 237 + "'", - value.equals(BigInteger.valueOf(237L))); + org.junit.Assert.assertTrue("'" + msg.data[146] + "' != '" + 237 + "'", value.equals(BigInteger.valueOf( 237L ) ) ); } else { value = value.longValue(); expected = 237L; @@ -1795,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.data[147]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[147] + "' != '" + 209 + "'", - value.equals(BigInteger.valueOf(209L))); + org.junit.Assert.assertTrue("'" + msg.data[147] + "' != '" + 209 + "'", value.equals(BigInteger.valueOf( 209L ) ) ); } else { value = value.longValue(); expected = 209L; @@ -1805,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.data[148]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[148] + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.data[148] + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -1815,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.data[149]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[149] + "' != '" + 226 + "'", - value.equals(BigInteger.valueOf(226L))); + org.junit.Assert.assertTrue("'" + msg.data[149] + "' != '" + 226 + "'", value.equals(BigInteger.valueOf( 226L ) ) ); } else { value = value.longValue(); expected = 226L; @@ -1825,8 +1274,7 @@ public void test1() throws Throwable { } value = msg.data[150]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[150] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.data[150] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1834,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.data[151]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[151] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.data[151] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -1844,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.data[152]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[152] + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.data[152] + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -1854,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.data[153]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[153] + "' != '" + 226 + "'", - value.equals(BigInteger.valueOf(226L))); + org.junit.Assert.assertTrue("'" + msg.data[153] + "' != '" + 226 + "'", value.equals(BigInteger.valueOf( 226L ) ) ); } else { value = value.longValue(); expected = 226L; @@ -1864,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.data[154]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[154] + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.data[154] + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -1874,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.data[155]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[155] + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.data[155] + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -1884,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.data[156]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[156] + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.data[156] + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -1894,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.data[157]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[157] + "' != '" + 159 + "'", - value.equals(BigInteger.valueOf(159L))); + org.junit.Assert.assertTrue("'" + msg.data[157] + "' != '" + 159 + "'", value.equals(BigInteger.valueOf( 159L ) ) ); } else { value = value.longValue(); expected = 159L; @@ -1904,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.data[158]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[158] + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.data[158] + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -1914,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.data[159]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[159] + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.data[159] + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -1924,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.data[160]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[160] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.data[160] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -1934,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.data[161]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[161] + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.data[161] + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1944,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.data[162]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[162] + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.data[162] + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -1954,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.data[163]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[163] + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.data[163] + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -1964,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.data[164]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[164] + "' != '" + 167 + "'", - value.equals(BigInteger.valueOf(167L))); + org.junit.Assert.assertTrue("'" + msg.data[164] + "' != '" + 167 + "'", value.equals(BigInteger.valueOf( 167L ) ) ); } else { value = value.longValue(); expected = 167L; @@ -1974,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.data[165]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[165] + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.data[165] + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -1984,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.data[166]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[166] + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.data[166] + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -1994,8 +1410,7 @@ public void test1() throws Throwable { } value = msg.data[167]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[167] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.data[167] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -2003,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.data[168]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[168] + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.data[168] + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -2013,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.data[169]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[169] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.data[169] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -2023,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.data[170]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[170] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.data[170] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -2033,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.data[171]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[171] + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.data[171] + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -2043,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.data[172]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[172] + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.data[172] + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -2053,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.data[173]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[173] + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.data[173] + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -2063,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.data[174]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[174] + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.data[174] + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -2073,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.data[175]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[175] + "' != '" + 250 + "'", - value.equals(BigInteger.valueOf(250L))); + org.junit.Assert.assertTrue("'" + msg.data[175] + "' != '" + 250 + "'", value.equals(BigInteger.valueOf( 250L ) ) ); } else { value = value.longValue(); expected = 250L; @@ -2083,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.data[176]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[176] + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.data[176] + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -2093,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.data[177]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[177] + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.data[177] + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -2103,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.data[178]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[178] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.data[178] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -2113,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.data[179]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[179] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.data[179] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -2123,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.data[180]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[180] + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.data[180] + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -2133,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.data[181]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[181] + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.data[181] + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -2143,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.data[182]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[182] + "' != '" + 243 + "'", - value.equals(BigInteger.valueOf(243L))); + org.junit.Assert.assertTrue("'" + msg.data[182] + "' != '" + 243 + "'", value.equals(BigInteger.valueOf( 243L ) ) ); } else { value = value.longValue(); expected = 243L; @@ -2153,9 +1538,7 @@ public void test1() throws Throwable { } value = msg.data[183]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[183] + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.data[183] + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -2163,8 +1546,7 @@ public void test1() throws Throwable { } value = msg.data[184]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[184] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.data[184] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -2172,9 +1554,7 @@ public void test1() throws Throwable { } value = msg.data[185]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[185] + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.data[185] + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -2182,9 +1562,7 @@ public void test1() throws Throwable { } value = msg.data[186]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[186] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.data[186] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -2192,9 +1570,7 @@ public void test1() throws Throwable { } value = msg.data[187]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[187] + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.data[187] + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -2202,9 +1578,7 @@ public void test1() throws Throwable { } value = msg.data[188]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[188] + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.data[188] + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -2212,9 +1586,7 @@ public void test1() throws Throwable { } value = msg.data[189]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[189] + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.data[189] + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -2222,9 +1594,7 @@ public void test1() throws Throwable { } value = msg.data[190]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[190] + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.data[190] + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -2232,9 +1602,7 @@ public void test1() throws Throwable { } value = msg.data[191]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[191] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.data[191] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -2242,9 +1610,7 @@ public void test1() throws Throwable { } value = msg.data[192]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[192] + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.data[192] + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -2252,9 +1618,7 @@ public void test1() throws Throwable { } value = msg.data[193]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[193] + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.data[193] + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -2262,9 +1626,7 @@ public void test1() throws Throwable { } value = msg.data[194]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[194] + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.data[194] + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -2272,9 +1634,7 @@ public void test1() throws Throwable { } value = msg.data[195]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[195] + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.data[195] + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -2282,9 +1642,7 @@ public void test1() throws Throwable { } value = msg.data[196]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[196] + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.data[196] + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -2292,9 +1650,7 @@ public void test1() throws Throwable { } value = msg.data[197]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[197] + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.data[197] + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -2302,9 +1658,7 @@ public void test1() throws Throwable { } value = msg.data[198]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[198] + "' != '" + 160 + "'", - value.equals(BigInteger.valueOf(160L))); + org.junit.Assert.assertTrue("'" + msg.data[198] + "' != '" + 160 + "'", value.equals(BigInteger.valueOf( 160L ) ) ); } else { value = value.longValue(); expected = 160L; @@ -2312,9 +1666,7 @@ public void test1() throws Throwable { } value = msg.data[199]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[199] + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.data[199] + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -2322,9 +1674,7 @@ public void test1() throws Throwable { } value = msg.data[200]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[200] + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.data[200] + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -2332,9 +1682,7 @@ public void test1() throws Throwable { } value = msg.data[201]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[201] + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.data[201] + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -2342,9 +1690,7 @@ public void test1() throws Throwable { } value = msg.data[202]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[202] + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.data[202] + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -2352,9 +1698,7 @@ public void test1() throws Throwable { } value = msg.data[203]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[203] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.data[203] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -2362,9 +1706,7 @@ public void test1() throws Throwable { } value = msg.data[204]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[204] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.data[204] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -2372,9 +1714,7 @@ public void test1() throws Throwable { } value = msg.data[205]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[205] + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.data[205] + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -2382,9 +1722,7 @@ public void test1() throws Throwable { } value = msg.data[206]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[206] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.data[206] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -2392,9 +1730,7 @@ public void test1() throws Throwable { } value = msg.data[207]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[207] + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.data[207] + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -2402,9 +1738,7 @@ public void test1() throws Throwable { } value = msg.data[208]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[208] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.data[208] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -2412,9 +1746,7 @@ public void test1() throws Throwable { } value = msg.data[209]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[209] + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.data[209] + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -2422,9 +1754,7 @@ public void test1() throws Throwable { } value = msg.data[210]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[210] + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.data[210] + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -2432,9 +1762,7 @@ public void test1() throws Throwable { } value = msg.data[211]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[211] + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.data[211] + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -2442,9 +1770,7 @@ public void test1() throws Throwable { } value = msg.data[212]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[212] + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.data[212] + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -2452,9 +1778,7 @@ public void test1() throws Throwable { } value = msg.data[213]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[213] + "' != '" + 239 + "'", - value.equals(BigInteger.valueOf(239L))); + org.junit.Assert.assertTrue("'" + msg.data[213] + "' != '" + 239 + "'", value.equals(BigInteger.valueOf( 239L ) ) ); } else { value = value.longValue(); expected = 239L; @@ -2462,9 +1786,7 @@ public void test1() throws Throwable { } value = msg.data[214]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[214] + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.data[214] + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -2472,9 +1794,7 @@ public void test1() throws Throwable { } value = msg.data[215]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[215] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.data[215] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -2482,9 +1802,7 @@ public void test1() throws Throwable { } value = msg.data[216]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[216] + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.data[216] + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -2492,9 +1810,7 @@ public void test1() throws Throwable { } value = msg.data[217]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[217] + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.data[217] + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -2502,9 +1818,7 @@ public void test1() throws Throwable { } value = msg.data[218]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[218] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.data[218] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -2512,9 +1826,7 @@ public void test1() throws Throwable { } value = msg.data[219]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[219] + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.data[219] + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -2522,9 +1834,7 @@ public void test1() throws Throwable { } value = msg.data[220]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[220] + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.data[220] + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -2532,9 +1842,7 @@ public void test1() throws Throwable { } value = msg.data[221]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[221] + "' != '" + 223 + "'", - value.equals(BigInteger.valueOf(223L))); + org.junit.Assert.assertTrue("'" + msg.data[221] + "' != '" + 223 + "'", value.equals(BigInteger.valueOf( 223L ) ) ); } else { value = value.longValue(); expected = 223L; @@ -2542,9 +1850,7 @@ public void test1() throws Throwable { } value = msg.data[222]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[222] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.data[222] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -2552,9 +1858,7 @@ public void test1() throws Throwable { } value = msg.data[223]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[223] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.data[223] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -2562,9 +1866,7 @@ public void test1() throws Throwable { } value = msg.data[224]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[224] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.data[224] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -2572,9 +1874,7 @@ public void test1() throws Throwable { } value = msg.data[225]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[225] + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.data[225] + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -2582,9 +1882,7 @@ public void test1() throws Throwable { } value = msg.data[226]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[226] + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.data[226] + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -2592,9 +1890,7 @@ public void test1() throws Throwable { } value = msg.data[227]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[227] + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.data[227] + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -2602,9 +1898,7 @@ public void test1() throws Throwable { } value = msg.data[228]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[228] + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.data[228] + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -2612,9 +1906,7 @@ public void test1() throws Throwable { } value = msg.data[229]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[229] + "' != '" + 251 + "'", - value.equals(BigInteger.valueOf(251L))); + org.junit.Assert.assertTrue("'" + msg.data[229] + "' != '" + 251 + "'", value.equals(BigInteger.valueOf( 251L ) ) ); } else { value = value.longValue(); expected = 251L; @@ -2622,9 +1914,7 @@ public void test1() throws Throwable { } value = msg.data[230]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[230] + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.data[230] + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -2632,9 +1922,7 @@ public void test1() throws Throwable { } value = msg.data[231]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[231] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.data[231] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -2642,9 +1930,7 @@ public void test1() throws Throwable { } value = msg.data[232]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[232] + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.data[232] + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -2652,9 +1938,7 @@ public void test1() throws Throwable { } value = msg.data[233]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[233] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.data[233] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -2662,9 +1946,7 @@ public void test1() throws Throwable { } value = msg.data[234]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[234] + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.data[234] + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -2672,9 +1954,7 @@ public void test1() throws Throwable { } value = msg.data[235]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[235] + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.data[235] + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -2682,9 +1962,7 @@ public void test1() throws Throwable { } value = msg.data[236]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[236] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.data[236] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -2692,9 +1970,7 @@ public void test1() throws Throwable { } value = msg.data[237]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[237] + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.data[237] + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -2702,9 +1978,7 @@ public void test1() throws Throwable { } value = msg.data[238]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[238] + "' != '" + 95 + "'", - value.equals(BigInteger.valueOf(95L))); + org.junit.Assert.assertTrue("'" + msg.data[238] + "' != '" + 95 + "'", value.equals(BigInteger.valueOf( 95L ) ) ); } else { value = value.longValue(); expected = 95L; @@ -2712,9 +1986,7 @@ public void test1() throws Throwable { } value = msg.data[239]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[239] + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.data[239] + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -2722,9 +1994,7 @@ public void test1() throws Throwable { } value = msg.data[240]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[240] + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.data[240] + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -2732,9 +2002,7 @@ public void test1() throws Throwable { } value = msg.data[241]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[241] + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.data[241] + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -2742,9 +2010,7 @@ public void test1() throws Throwable { } value = msg.data[242]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[242] + "' != '" + 164 + "'", - value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.data[242] + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -2752,9 +2018,7 @@ public void test1() throws Throwable { } value = msg.data[243]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[243] + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.data[243] + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -2762,9 +2026,7 @@ public void test1() throws Throwable { } value = msg.data[244]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[244] + "' != '" + 197 + "'", - value.equals(BigInteger.valueOf(197L))); + org.junit.Assert.assertTrue("'" + msg.data[244] + "' != '" + 197 + "'", value.equals(BigInteger.valueOf( 197L ) ) ); } else { value = value.longValue(); expected = 197L; @@ -2772,9 +2034,7 @@ public void test1() throws Throwable { } value = msg.data[245]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[245] + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.data[245] + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -2782,9 +2042,7 @@ public void test1() throws Throwable { } value = msg.data[246]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[246] + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.data[246] + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -2792,9 +2050,7 @@ public void test1() throws Throwable { } value = msg.data[247]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[247] + "' != '" + 223 + "'", - value.equals(BigInteger.valueOf(223L))); + org.junit.Assert.assertTrue("'" + msg.data[247] + "' != '" + 223 + "'", value.equals(BigInteger.valueOf( 223L ) ) ); } else { value = value.longValue(); expected = 223L; @@ -2802,9 +2058,7 @@ public void test1() throws Throwable { } value = msg.data[248]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[248] + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.data[248] + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -2812,9 +2066,7 @@ public void test1() throws Throwable { } value = msg.data[249]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.data[249] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.data[249] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -2822,9 +2074,7 @@ public void test1() throws Throwable { } value = msg.target; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.target + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.target + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; diff --git a/java/test/auto_check_sbp_flash_MsgFlashReadReqTest.java b/java/test/auto_check_sbp_flash_MsgFlashReadReqTest.java index e50f01a70..a0501d930 100644 --- a/java/test/auto_check_sbp_flash_MsgFlashReadReqTest.java +++ b/java/test/auto_check_sbp_flash_MsgFlashReadReqTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgFlashReadReq.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgFlashReadReq.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.flash.MsgFlashReadReq; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_flash_MsgFlashReadReqTest { @@ -27,21 +32,17 @@ public class auto_check_sbp_flash_MsgFlashReadReqTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_flash_MsgFlashReadReqTest.test1"); - byte[] payload = - new byte[] { - (byte) 241, (byte) 28, (byte) 75, (byte) 244, (byte) 71, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0xe7, payload); - MsgFlashReadReq msg = new MsgFlashReadReq(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_flash_MsgFlashReadReqTest.test1"); + byte[] payload = new byte[] {(byte)241,(byte)28,(byte)75,(byte)244,(byte)71, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0xe7, payload ); + MsgFlashReadReq msg = new MsgFlashReadReq( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.addr_len; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.addr_len + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.addr_len + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -49,9 +50,7 @@ public void test1() throws Throwable { } value = msg.addr_start[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.addr_start[0] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.addr_start[0] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -59,9 +58,7 @@ public void test1() throws Throwable { } value = msg.addr_start[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.addr_start[1] + "' != '" + 75 + "'", - value.equals(BigInteger.valueOf(75L))); + org.junit.Assert.assertTrue("'" + msg.addr_start[1] + "' != '" + 75 + "'", value.equals(BigInteger.valueOf( 75L ) ) ); } else { value = value.longValue(); expected = 75L; @@ -69,9 +66,7 @@ public void test1() throws Throwable { } value = msg.addr_start[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.addr_start[2] + "' != '" + 244 + "'", - value.equals(BigInteger.valueOf(244L))); + org.junit.Assert.assertTrue("'" + msg.addr_start[2] + "' != '" + 244 + "'", value.equals(BigInteger.valueOf( 244L ) ) ); } else { value = value.longValue(); expected = 244L; @@ -79,9 +74,7 @@ public void test1() throws Throwable { } value = msg.target; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.target + "' != '" + 241 + "'", - value.equals(BigInteger.valueOf(241L))); + org.junit.Assert.assertTrue("'" + msg.target + "' != '" + 241 + "'", value.equals(BigInteger.valueOf( 241L ) ) ); } else { value = value.longValue(); expected = 241L; diff --git a/java/test/auto_check_sbp_flash_MsgFlashReadRespTest.java b/java/test/auto_check_sbp_flash_MsgFlashReadRespTest.java index a8132a45b..8d88910f1 100644 --- a/java/test/auto_check_sbp_flash_MsgFlashReadRespTest.java +++ b/java/test/auto_check_sbp_flash_MsgFlashReadRespTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgFlashReadResp.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgFlashReadResp.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.flash.MsgFlashReadResp; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_flash_MsgFlashReadRespTest { @@ -27,21 +32,17 @@ public class auto_check_sbp_flash_MsgFlashReadRespTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_flash_MsgFlashReadRespTest.test1"); - byte[] payload = - new byte[] { - (byte) 136, (byte) 155, (byte) 52, (byte) 172, (byte) 124, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0xe1, payload); - MsgFlashReadResp msg = new MsgFlashReadResp(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_flash_MsgFlashReadRespTest.test1"); + byte[] payload = new byte[] {(byte)136,(byte)155,(byte)52,(byte)172,(byte)124, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0xe1, payload ); + MsgFlashReadResp msg = new MsgFlashReadResp( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.addr_len; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.addr_len + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.addr_len + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -49,9 +50,7 @@ public void test1() throws Throwable { } value = msg.addr_start[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.addr_start[0] + "' != '" + 155 + "'", - value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.addr_start[0] + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -59,9 +58,7 @@ public void test1() throws Throwable { } value = msg.addr_start[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.addr_start[1] + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.addr_start[1] + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -69,9 +66,7 @@ public void test1() throws Throwable { } value = msg.addr_start[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.addr_start[2] + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.addr_start[2] + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -79,9 +74,7 @@ public void test1() throws Throwable { } value = msg.target; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.target + "' != '" + 136 + "'", - value.equals(BigInteger.valueOf(136L))); + org.junit.Assert.assertTrue("'" + msg.target + "' != '" + 136 + "'", value.equals(BigInteger.valueOf( 136L ) ) ); } else { value = value.longValue(); expected = 136L; diff --git a/java/test/auto_check_sbp_flash_MsgM25FlashWriteStatusTest.java b/java/test/auto_check_sbp_flash_MsgM25FlashWriteStatusTest.java index a3f05aa98..21a09589a 100644 --- a/java/test/auto_check_sbp_flash_MsgM25FlashWriteStatusTest.java +++ b/java/test/auto_check_sbp_flash_MsgM25FlashWriteStatusTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/flash/test_MsgM25FlashWriteStatus.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgM25FlashWriteStatus.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.flash.MsgM25FlashWriteStatus; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_flash_MsgM25FlashWriteStatusTest { @@ -30,19 +34,15 @@ public class auto_check_sbp_flash_MsgM25FlashWriteStatusTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_flash_MsgM25FlashWriteStatusTest.test1"); - byte[] payload = - new byte[] { - (byte) 5, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0xf3, payload); - MsgM25FlashWriteStatus msg = new MsgM25FlashWriteStatus(sbp); + byte[] payload = new byte[] {(byte)5, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0xf3, payload ); + MsgM25FlashWriteStatus msg = new MsgM25FlashWriteStatus( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.status[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[0] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.status[0] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; diff --git a/java/test/auto_check_sbp_flash_MsgStmFlashLockSectorTest.java b/java/test/auto_check_sbp_flash_MsgStmFlashLockSectorTest.java index 280a07478..feeaafa87 100644 --- a/java/test/auto_check_sbp_flash_MsgStmFlashLockSectorTest.java +++ b/java/test/auto_check_sbp_flash_MsgStmFlashLockSectorTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/flash/test_MsgStmFlashLockSector.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgStmFlashLockSector.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.flash.MsgStmFlashLockSector; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_flash_MsgStmFlashLockSectorTest { @@ -30,20 +34,15 @@ public class auto_check_sbp_flash_MsgStmFlashLockSectorTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_flash_MsgStmFlashLockSectorTest.test1"); - byte[] payload = - new byte[] { - (byte) 161, (byte) 247, (byte) 197, (byte) 67, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0xe3, payload); - MsgStmFlashLockSector msg = new MsgStmFlashLockSector(sbp); + byte[] payload = new byte[] {(byte)161,(byte)247,(byte)197,(byte)67, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0xe3, payload ); + MsgStmFlashLockSector msg = new MsgStmFlashLockSector( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.sector; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sector + "' != '" + 1137047457 + "'", - value.equals(BigInteger.valueOf(1137047457L))); + org.junit.Assert.assertTrue("'" + msg.sector + "' != '" + 1137047457 + "'", value.equals(BigInteger.valueOf( 1137047457L ) ) ); } else { value = value.longValue(); expected = 1137047457L; diff --git a/java/test/auto_check_sbp_flash_MsgStmFlashUnlockSectorTest.java b/java/test/auto_check_sbp_flash_MsgStmFlashUnlockSectorTest.java index 3f5958a87..38326489c 100644 --- a/java/test/auto_check_sbp_flash_MsgStmFlashUnlockSectorTest.java +++ b/java/test/auto_check_sbp_flash_MsgStmFlashUnlockSectorTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/flash/test_MsgStmFlashUnlockSector.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgStmFlashUnlockSector.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.flash.MsgStmFlashUnlockSector; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_flash_MsgStmFlashUnlockSectorTest { @@ -30,20 +34,15 @@ public class auto_check_sbp_flash_MsgStmFlashUnlockSectorTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_flash_MsgStmFlashUnlockSectorTest.test1"); - byte[] payload = - new byte[] { - (byte) 31, (byte) 16, (byte) 231, (byte) 49, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0xe4, payload); - MsgStmFlashUnlockSector msg = new MsgStmFlashUnlockSector(sbp); + byte[] payload = new byte[] {(byte)31,(byte)16,(byte)231,(byte)49, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0xe4, payload ); + MsgStmFlashUnlockSector msg = new MsgStmFlashUnlockSector( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.sector; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sector + "' != '" + 837226527 + "'", - value.equals(BigInteger.valueOf(837226527L))); + org.junit.Assert.assertTrue("'" + msg.sector + "' != '" + 837226527 + "'", value.equals(BigInteger.valueOf( 837226527L ) ) ); } else { value = value.longValue(); expected = 837226527L; diff --git a/java/test/auto_check_sbp_flash_MsgStmUniqueIdReqTest.java b/java/test/auto_check_sbp_flash_MsgStmUniqueIdReqTest.java index 2126f205f..52a2b695e 100644 --- a/java/test/auto_check_sbp_flash_MsgStmUniqueIdReqTest.java +++ b/java/test/auto_check_sbp_flash_MsgStmUniqueIdReqTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,16 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgStmUniqueIdReq.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgStmUniqueIdReq.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; +import org.junit.Test; + +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.flash.MsgStmUniqueIdReq; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_flash_MsgStmUniqueIdReqTest { @@ -26,10 +32,11 @@ public class auto_check_sbp_flash_MsgStmUniqueIdReqTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_flash_MsgStmUniqueIdReqTest.test1"); - byte[] payload = new byte[] {}; - SBPMessage sbp = new SBPMessage(0x04c3, 0xe8, payload); - MsgStmUniqueIdReq msg = new MsgStmUniqueIdReq(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_flash_MsgStmUniqueIdReqTest.test1"); + byte[] payload = new byte[] { }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0xe8, payload ); + MsgStmUniqueIdReq msg = new MsgStmUniqueIdReq( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; diff --git a/java/test/auto_check_sbp_flash_MsgStmUniqueIdRespTest.java b/java/test/auto_check_sbp_flash_MsgStmUniqueIdRespTest.java index 5781a0f78..0312a9322 100644 --- a/java/test/auto_check_sbp_flash_MsgStmUniqueIdRespTest.java +++ b/java/test/auto_check_sbp_flash_MsgStmUniqueIdRespTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgStmUniqueIdResp.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/flash/test_MsgStmUniqueIdResp.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.flash.MsgStmUniqueIdResp; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_flash_MsgStmUniqueIdRespTest { @@ -27,32 +32,17 @@ public class auto_check_sbp_flash_MsgStmUniqueIdRespTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_flash_MsgStmUniqueIdRespTest.test1"); - byte[] payload = - new byte[] { - (byte) 196, - (byte) 16, - (byte) 15, - (byte) 163, - (byte) 85, - (byte) 221, - (byte) 119, - (byte) 102, - (byte) 32, - (byte) 194, - (byte) 56, - (byte) 144, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0xe5, payload); - MsgStmUniqueIdResp msg = new MsgStmUniqueIdResp(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_flash_MsgStmUniqueIdRespTest.test1"); + byte[] payload = new byte[] {(byte)196,(byte)16,(byte)15,(byte)163,(byte)85,(byte)221,(byte)119,(byte)102,(byte)32,(byte)194,(byte)56,(byte)144, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0xe5, payload ); + MsgStmUniqueIdResp msg = new MsgStmUniqueIdResp( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.stm_id[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stm_id[0] + "' != '" + 196 + "'", - value.equals(BigInteger.valueOf(196L))); + org.junit.Assert.assertTrue("'" + msg.stm_id[0] + "' != '" + 196 + "'", value.equals(BigInteger.valueOf( 196L ) ) ); } else { value = value.longValue(); expected = 196L; @@ -60,9 +50,7 @@ public void test1() throws Throwable { } value = msg.stm_id[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stm_id[1] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.stm_id[1] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -70,9 +58,7 @@ public void test1() throws Throwable { } value = msg.stm_id[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stm_id[2] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.stm_id[2] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -80,9 +66,7 @@ public void test1() throws Throwable { } value = msg.stm_id[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stm_id[3] + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.stm_id[3] + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -90,9 +74,7 @@ public void test1() throws Throwable { } value = msg.stm_id[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stm_id[4] + "' != '" + 85 + "'", - value.equals(BigInteger.valueOf(85L))); + org.junit.Assert.assertTrue("'" + msg.stm_id[4] + "' != '" + 85 + "'", value.equals(BigInteger.valueOf( 85L ) ) ); } else { value = value.longValue(); expected = 85L; @@ -100,9 +82,7 @@ public void test1() throws Throwable { } value = msg.stm_id[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stm_id[5] + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.stm_id[5] + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -110,9 +90,7 @@ public void test1() throws Throwable { } value = msg.stm_id[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stm_id[6] + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.stm_id[6] + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -120,9 +98,7 @@ public void test1() throws Throwable { } value = msg.stm_id[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stm_id[7] + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.stm_id[7] + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -130,9 +106,7 @@ public void test1() throws Throwable { } value = msg.stm_id[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stm_id[8] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.stm_id[8] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -140,9 +114,7 @@ public void test1() throws Throwable { } value = msg.stm_id[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stm_id[9] + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.stm_id[9] + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -150,9 +122,7 @@ public void test1() throws Throwable { } value = msg.stm_id[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stm_id[10] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.stm_id[10] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -160,9 +130,7 @@ public void test1() throws Throwable { } value = msg.stm_id[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stm_id[11] + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.stm_id[11] + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; diff --git a/java/test/auto_check_sbp_gnss_gnss_structsTest.java b/java/test/auto_check_sbp_gnss_gnss_structsTest.java index b733b094b..3531ed26f 100644 --- a/java/test/auto_check_sbp_gnss_gnss_structsTest.java +++ b/java/test/auto_check_sbp_gnss_gnss_structsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,10 +9,19 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/gnss/test_gnss_structs.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/gnss/test_gnss_structs.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; + +import org.json.JSONObject; + +import com.swiftnav.sbp.SBPMessage; + public class auto_check_sbp_gnss_gnss_structsTest { diff --git a/java/test/auto_check_sbp_imu_MsgImuAuxTest.java b/java/test/auto_check_sbp_imu_MsgImuAuxTest.java index 4d3fe303f..7e80c4aac 100644 --- a/java/test/auto_check_sbp_imu_MsgImuAuxTest.java +++ b/java/test/auto_check_sbp_imu_MsgImuAuxTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/imu/test_MsgImuAux.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/imu/test_MsgImuAux.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.imu.MsgImuAux; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_imu_MsgImuAuxTest { @@ -27,21 +32,17 @@ public class auto_check_sbp_imu_MsgImuAuxTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_imu_MsgImuAuxTest.test1"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 244, (byte) 10, (byte) 66, - }; - SBPMessage sbp = new SBPMessage(0x1234, 0x901, payload); - MsgImuAux msg = new MsgImuAux(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_imu_MsgImuAuxTest.test1"); + byte[] payload = new byte[] {(byte)1,(byte)244,(byte)10,(byte)66, }; + SBPMessage sbp = new SBPMessage( 0x1234, 0x901, payload ); + MsgImuAux msg = new MsgImuAux( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.imu_conf; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.imu_conf + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.imu_conf + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -49,8 +50,7 @@ public void test1() throws Throwable { } value = msg.imu_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.imu_type + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.imu_type + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -58,9 +58,7 @@ public void test1() throws Throwable { } value = msg.temp; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.temp + "' != '" + 2804 + "'", - value.equals(BigInteger.valueOf(2804L))); + org.junit.Assert.assertTrue("'" + msg.temp + "' != '" + 2804 + "'", value.equals(BigInteger.valueOf( 2804L ) ) ); } else { value = value.longValue(); expected = 2804L; diff --git a/java/test/auto_check_sbp_imu_MsgImuCompTest.java b/java/test/auto_check_sbp_imu_MsgImuCompTest.java index 78849cd47..1e47c070a 100644 --- a/java/test/auto_check_sbp_imu_MsgImuCompTest.java +++ b/java/test/auto_check_sbp_imu_MsgImuCompTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/imu/test_MsgImuComp.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/imu/test_MsgImuComp.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.imu.MsgImuComp; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_imu_MsgImuCompTest { @@ -27,25 +32,17 @@ public class auto_check_sbp_imu_MsgImuCompTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_imu_MsgImuCompTest.test1"); - byte[] payload = - new byte[] { - (byte) 26, (byte) 1, (byte) 0, (byte) 192, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 206, (byte) 0, (byte) 96, (byte) 0, (byte) 0, (byte) 0, - (byte) 223, (byte) 255, (byte) 255, (byte) 255, (byte) 44, (byte) 16, (byte) 0, - (byte) 0, (byte) 60, (byte) 0, (byte) 0, (byte) 0, (byte) 208, (byte) 254, - (byte) 255, (byte) 255, (byte) 238, (byte) 255, (byte) 255, (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0x1234, 0x905, payload); - MsgImuComp msg = new MsgImuComp(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_imu_MsgImuCompTest.test1"); + byte[] payload = new byte[] {(byte)26,(byte)1,(byte)0,(byte)192,(byte)0,(byte)0,(byte)0,(byte)0,(byte)206,(byte)0,(byte)96,(byte)0,(byte)0,(byte)0,(byte)223,(byte)255,(byte)255,(byte)255,(byte)44,(byte)16,(byte)0,(byte)0,(byte)60,(byte)0,(byte)0,(byte)0,(byte)208,(byte)254,(byte)255,(byte)255,(byte)238,(byte)255,(byte)255,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0x1234, 0x905, payload ); + MsgImuComp msg = new MsgImuComp( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.acc_comp_x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acc_comp_x + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.acc_comp_x + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -53,9 +50,7 @@ public void test1() throws Throwable { } value = msg.acc_comp_y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acc_comp_y + "' != '" + -33 + "'", - value.equals(BigInteger.valueOf(-33L))); + org.junit.Assert.assertTrue("'" + msg.acc_comp_y + "' != '" + -33 + "'", value.equals(BigInteger.valueOf( -33L ) ) ); } else { value = value.longValue(); expected = -33L; @@ -63,9 +58,7 @@ public void test1() throws Throwable { } value = msg.acc_comp_z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acc_comp_z + "' != '" + 4140 + "'", - value.equals(BigInteger.valueOf(4140L))); + org.junit.Assert.assertTrue("'" + msg.acc_comp_z + "' != '" + 4140 + "'", value.equals(BigInteger.valueOf( 4140L ) ) ); } else { value = value.longValue(); expected = 4140L; @@ -73,8 +66,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 206 + "'", value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; @@ -82,9 +74,7 @@ public void test1() throws Throwable { } value = msg.gyr_comp_x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gyr_comp_x + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.gyr_comp_x + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -92,9 +82,7 @@ public void test1() throws Throwable { } value = msg.gyr_comp_y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gyr_comp_y + "' != '" + -304 + "'", - value.equals(BigInteger.valueOf(-304L))); + org.junit.Assert.assertTrue("'" + msg.gyr_comp_y + "' != '" + -304 + "'", value.equals(BigInteger.valueOf( -304L ) ) ); } else { value = value.longValue(); expected = -304L; @@ -102,9 +90,7 @@ public void test1() throws Throwable { } value = msg.gyr_comp_z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gyr_comp_z + "' != '" + -18 + "'", - value.equals(BigInteger.valueOf(-18L))); + org.junit.Assert.assertTrue("'" + msg.gyr_comp_z + "' != '" + -18 + "'", value.equals(BigInteger.valueOf( -18L ) ) ); } else { value = value.longValue(); expected = -18L; @@ -112,9 +98,7 @@ public void test1() throws Throwable { } value = msg.time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time + "' != '" + 3221225754L + "'", - value.equals(new BigInteger("3221225754"))); + org.junit.Assert.assertTrue("'" + msg.time + "' != '" + 3221225754L + "'", value.equals( new BigInteger( "3221225754" ) ) ); } else { value = value.longValue(); expected = 3221225754L; diff --git a/java/test/auto_check_sbp_imu_MsgImuRawTest.java b/java/test/auto_check_sbp_imu_MsgImuRawTest.java index 314ceb21d..0b3b5b2e3 100644 --- a/java/test/auto_check_sbp_imu_MsgImuRawTest.java +++ b/java/test/auto_check_sbp_imu_MsgImuRawTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/imu/test_MsgImuRaw.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/imu/test_MsgImuRaw.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.imu.MsgImuRaw; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_imu_MsgImuRawTest { @@ -27,22 +32,17 @@ public class auto_check_sbp_imu_MsgImuRawTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_imu_MsgImuRawTest.test1"); - byte[] payload = - new byte[] { - (byte) 26, (byte) 1, (byte) 0, (byte) 192, (byte) 206, (byte) 96, (byte) 0, - (byte) 223, (byte) 255, (byte) 44, (byte) 16, (byte) 60, (byte) 0, (byte) 208, - (byte) 254, (byte) 238, (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0x1234, 0x900, payload); - MsgImuRaw msg = new MsgImuRaw(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_imu_MsgImuRawTest.test1"); + byte[] payload = new byte[] {(byte)26,(byte)1,(byte)0,(byte)192,(byte)206,(byte)96,(byte)0,(byte)223,(byte)255,(byte)44,(byte)16,(byte)60,(byte)0,(byte)208,(byte)254,(byte)238,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0x1234, 0x900, payload ); + MsgImuRaw msg = new MsgImuRaw( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.acc_x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acc_x + "' != '" + 96 + "'", value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.acc_x + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -50,8 +50,7 @@ public void test1() throws Throwable { } value = msg.acc_y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acc_y + "' != '" + -33 + "'", value.equals(BigInteger.valueOf(-33L))); + org.junit.Assert.assertTrue("'" + msg.acc_y + "' != '" + -33 + "'", value.equals(BigInteger.valueOf( -33L ) ) ); } else { value = value.longValue(); expected = -33L; @@ -59,9 +58,7 @@ public void test1() throws Throwable { } value = msg.acc_z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acc_z + "' != '" + 4140 + "'", - value.equals(BigInteger.valueOf(4140L))); + org.junit.Assert.assertTrue("'" + msg.acc_z + "' != '" + 4140 + "'", value.equals(BigInteger.valueOf( 4140L ) ) ); } else { value = value.longValue(); expected = 4140L; @@ -69,8 +66,7 @@ public void test1() throws Throwable { } value = msg.gyr_x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gyr_x + "' != '" + 60 + "'", value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.gyr_x + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -78,9 +74,7 @@ public void test1() throws Throwable { } value = msg.gyr_y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gyr_y + "' != '" + -304 + "'", - value.equals(BigInteger.valueOf(-304L))); + org.junit.Assert.assertTrue("'" + msg.gyr_y + "' != '" + -304 + "'", value.equals(BigInteger.valueOf( -304L ) ) ); } else { value = value.longValue(); expected = -304L; @@ -88,8 +82,7 @@ public void test1() throws Throwable { } value = msg.gyr_z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gyr_z + "' != '" + -18 + "'", value.equals(BigInteger.valueOf(-18L))); + org.junit.Assert.assertTrue("'" + msg.gyr_z + "' != '" + -18 + "'", value.equals(BigInteger.valueOf( -18L ) ) ); } else { value = value.longValue(); expected = -18L; @@ -97,9 +90,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 3221225754L + "'", - value.equals(new BigInteger("3221225754"))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 3221225754L + "'", value.equals( new BigInteger( "3221225754" ) ) ); } else { value = value.longValue(); expected = 3221225754L; @@ -107,8 +98,7 @@ public void test1() throws Throwable { } value = msg.tow_f; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow_f + "' != '" + 206 + "'", value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.tow_f + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; diff --git a/java/test/auto_check_sbp_integrity_MsgAcknowledgeTest.java b/java/test/auto_check_sbp_integrity_MsgAcknowledgeTest.java index c6b48288e..14ef278fd 100644 --- a/java/test/auto_check_sbp_integrity_MsgAcknowledgeTest.java +++ b/java/test/auto_check_sbp_integrity_MsgAcknowledgeTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgAcknowledge.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgAcknowledge.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.integrity.MsgAcknowledge; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_integrity_MsgAcknowledgeTest { @@ -27,31 +32,17 @@ public class auto_check_sbp_integrity_MsgAcknowledgeTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_integrity_MsgAcknowledgeTest.test1"); - byte[] payload = - new byte[] { - (byte) 30, - (byte) 64, - (byte) 226, - (byte) 1, - (byte) 0, - (byte) 0, - (byte) 1, - (byte) 0, - (byte) 1, - (byte) 0, - (byte) 2, - }; - SBPMessage sbp = new SBPMessage(0x2A, 0xBD2, payload); - MsgAcknowledge msg = new MsgAcknowledge(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_integrity_MsgAcknowledgeTest.test1"); + byte[] payload = new byte[] {(byte)30,(byte)64,(byte)226,(byte)1,(byte)0,(byte)0,(byte)1,(byte)0,(byte)1,(byte)0,(byte)2, }; + SBPMessage sbp = new SBPMessage( 0x2A, 0xBD2, payload ); + MsgAcknowledge msg = new MsgAcknowledge( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.area_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.area_id + "' != '" + 123456 + "'", - value.equals(BigInteger.valueOf(123456L))); + org.junit.Assert.assertTrue("'" + msg.area_id + "' != '" + 123456 + "'", value.equals(BigInteger.valueOf( 123456L ) ) ); } else { value = value.longValue(); expected = 123456L; @@ -59,9 +50,7 @@ public void test1() throws Throwable { } value = msg.correction_mask_on_demand; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.correction_mask_on_demand + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.correction_mask_on_demand + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -69,9 +58,7 @@ public void test1() throws Throwable { } value = msg.correction_mask_stream; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.correction_mask_stream + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.correction_mask_stream + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -79,9 +66,7 @@ public void test1() throws Throwable { } value = msg.request_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.request_id + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.request_id + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -89,9 +74,7 @@ public void test1() throws Throwable { } value = msg.response_code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.response_code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.response_code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -99,9 +82,7 @@ public void test1() throws Throwable { } value = msg.solution_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.solution_id + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.solution_id + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.java index 56d5f592c..c2c43be61 100644 --- a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.java +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevelDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevelDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest { @@ -29,52 +33,16 @@ public class auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 180, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 3, - (byte) 0, - (byte) 104, - (byte) 1, - (byte) 0, - (byte) 0, - (byte) 6, - (byte) 0, - (byte) 10, - (byte) 20, - (byte) 0, - (byte) 30, - (byte) 0, - (byte) 40, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 8, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x0BB9, payload); - MsgSsrFlagHighLevelDepA msg = new MsgSsrFlagHighLevelDepA(sbp); + System.out.format("%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagHighLevelDepATest.test1"); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)104,(byte)1,(byte)0,(byte)0,(byte)6,(byte)0,(byte)10,(byte)20,(byte)0,(byte)30,(byte)0,(byte)40,(byte)1,(byte)2,(byte)3,(byte)4,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)5,(byte)6,(byte)7,(byte)8, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x0BB9, payload ); + MsgSsrFlagHighLevelDepA msg = new MsgSsrFlagHighLevelDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.chain_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.chain_id + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.chain_id + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -82,9 +50,7 @@ public void test1() throws Throwable { } value = msg.corr_time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corr_time.tow + "' != '" + 360 + "'", - value.equals(BigInteger.valueOf(360L))); + org.junit.Assert.assertTrue("'" + msg.corr_time.tow + "' != '" + 360 + "'", value.equals(BigInteger.valueOf( 360L ) ) ); } else { value = value.longValue(); expected = 360L; @@ -92,9 +58,7 @@ public void test1() throws Throwable { } value = msg.corr_time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corr_time.wn + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.corr_time.wn + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -102,9 +66,7 @@ public void test1() throws Throwable { } value = msg.obs_time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.obs_time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.obs_time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -112,9 +74,7 @@ public void test1() throws Throwable { } value = msg.obs_time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.obs_time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.obs_time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -122,9 +82,7 @@ public void test1() throws Throwable { } value = msg.reserved[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reserved[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.reserved[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -132,9 +90,7 @@ public void test1() throws Throwable { } value = msg.reserved[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reserved[1] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.reserved[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -142,9 +98,7 @@ public void test1() throws Throwable { } value = msg.reserved[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reserved[2] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.reserved[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -152,9 +106,7 @@ public void test1() throws Throwable { } value = msg.reserved[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reserved[3] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.reserved[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -162,9 +114,7 @@ public void test1() throws Throwable { } value = msg.reserved[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reserved[4] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.reserved[4] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -172,9 +122,7 @@ public void test1() throws Throwable { } value = msg.ssr_sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ssr_sol_id + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.ssr_sol_id + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -182,8 +130,7 @@ public void test1() throws Throwable { } value = msg.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_id + "' != '" + 30 + "'", value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.tile_id + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -191,9 +138,7 @@ public void test1() throws Throwable { } value = msg.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_set_id + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.tile_set_id + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -201,9 +146,7 @@ public void test1() throws Throwable { } value = msg.use_bds_sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_bds_sat + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.use_bds_sat + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -211,9 +154,7 @@ public void test1() throws Throwable { } value = msg.use_gal_sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_gal_sat + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.use_gal_sat + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -221,9 +162,7 @@ public void test1() throws Throwable { } value = msg.use_gps_sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_gps_sat + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.use_gps_sat + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -231,9 +170,7 @@ public void test1() throws Throwable { } value = msg.use_iono_grid_point_sat_los; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_iono_grid_point_sat_los + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.use_iono_grid_point_sat_los + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -241,9 +178,7 @@ public void test1() throws Throwable { } value = msg.use_iono_grid_points; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_iono_grid_points + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.use_iono_grid_points + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -251,9 +186,7 @@ public void test1() throws Throwable { } value = msg.use_iono_tile_sat_los; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_iono_tile_sat_los + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.use_iono_tile_sat_los + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -261,9 +194,7 @@ public void test1() throws Throwable { } value = msg.use_qzss_sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_qzss_sat + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.use_qzss_sat + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -271,9 +202,7 @@ public void test1() throws Throwable { } value = msg.use_tropo_grid_points; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_tropo_grid_points + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.use_tropo_grid_points + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java index 30a95941a..5c86bd1a6 100644 --- a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.integrity.MsgSsrFlagHighLevel; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_integrity_MsgSsrFlagHighLevelTest { @@ -30,56 +34,15 @@ public class auto_check_sbp_integrity_MsgSsrFlagHighLevelTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.test1"); - byte[] payload = - new byte[] { - (byte) 180, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 3, - (byte) 0, - (byte) 109, - (byte) 1, - (byte) 0, - (byte) 0, - (byte) 6, - (byte) 0, - (byte) 104, - (byte) 1, - (byte) 0, - (byte) 0, - (byte) 6, - (byte) 0, - (byte) 10, - (byte) 20, - (byte) 0, - (byte) 30, - (byte) 0, - (byte) 40, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 8, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x0BBA, payload); - MsgSsrFlagHighLevel msg = new MsgSsrFlagHighLevel(sbp); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)109,(byte)1,(byte)0,(byte)0,(byte)6,(byte)0,(byte)104,(byte)1,(byte)0,(byte)0,(byte)6,(byte)0,(byte)10,(byte)20,(byte)0,(byte)30,(byte)0,(byte)40,(byte)1,(byte)2,(byte)3,(byte)4,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)5,(byte)6,(byte)7,(byte)8, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x0BBA, payload ); + MsgSsrFlagHighLevel msg = new MsgSsrFlagHighLevel( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.atmo_corr_time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.atmo_corr_time.tow + "' != '" + 365 + "'", - value.equals(BigInteger.valueOf(365L))); + org.junit.Assert.assertTrue("'" + msg.atmo_corr_time.tow + "' != '" + 365 + "'", value.equals(BigInteger.valueOf( 365L ) ) ); } else { value = value.longValue(); expected = 365L; @@ -87,9 +50,7 @@ public void test1() throws Throwable { } value = msg.atmo_corr_time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.atmo_corr_time.wn + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.atmo_corr_time.wn + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -97,9 +58,7 @@ public void test1() throws Throwable { } value = msg.chain_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.chain_id + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.chain_id + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -107,9 +66,7 @@ public void test1() throws Throwable { } value = msg.obs_time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.obs_time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.obs_time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -117,9 +74,7 @@ public void test1() throws Throwable { } value = msg.obs_time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.obs_time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.obs_time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -127,9 +82,7 @@ public void test1() throws Throwable { } value = msg.reserved[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reserved[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.reserved[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -137,9 +90,7 @@ public void test1() throws Throwable { } value = msg.reserved[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reserved[1] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.reserved[1] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -147,9 +98,7 @@ public void test1() throws Throwable { } value = msg.reserved[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reserved[2] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.reserved[2] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -157,9 +106,7 @@ public void test1() throws Throwable { } value = msg.reserved[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reserved[3] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.reserved[3] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -167,9 +114,7 @@ public void test1() throws Throwable { } value = msg.reserved[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reserved[4] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.reserved[4] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -177,9 +122,7 @@ public void test1() throws Throwable { } value = msg.sat_corr_time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sat_corr_time.tow + "' != '" + 360 + "'", - value.equals(BigInteger.valueOf(360L))); + org.junit.Assert.assertTrue("'" + msg.sat_corr_time.tow + "' != '" + 360 + "'", value.equals(BigInteger.valueOf( 360L ) ) ); } else { value = value.longValue(); expected = 360L; @@ -187,9 +130,7 @@ public void test1() throws Throwable { } value = msg.sat_corr_time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sat_corr_time.wn + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.sat_corr_time.wn + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -197,9 +138,7 @@ public void test1() throws Throwable { } value = msg.ssr_sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ssr_sol_id + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.ssr_sol_id + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -207,8 +146,7 @@ public void test1() throws Throwable { } value = msg.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_id + "' != '" + 30 + "'", value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.tile_id + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -216,9 +154,7 @@ public void test1() throws Throwable { } value = msg.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_set_id + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.tile_set_id + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -226,9 +162,7 @@ public void test1() throws Throwable { } value = msg.use_bds_sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_bds_sat + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.use_bds_sat + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -236,9 +170,7 @@ public void test1() throws Throwable { } value = msg.use_gal_sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_gal_sat + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.use_gal_sat + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -246,9 +178,7 @@ public void test1() throws Throwable { } value = msg.use_gps_sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_gps_sat + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.use_gps_sat + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -256,9 +186,7 @@ public void test1() throws Throwable { } value = msg.use_iono_grid_point_sat_los; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_iono_grid_point_sat_los + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.use_iono_grid_point_sat_los + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -266,9 +194,7 @@ public void test1() throws Throwable { } value = msg.use_iono_grid_points; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_iono_grid_points + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.use_iono_grid_points + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -276,9 +202,7 @@ public void test1() throws Throwable { } value = msg.use_iono_tile_sat_los; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_iono_tile_sat_los + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.use_iono_tile_sat_los + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -286,9 +210,7 @@ public void test1() throws Throwable { } value = msg.use_qzss_sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_qzss_sat + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.use_qzss_sat + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -296,9 +218,7 @@ public void test1() throws Throwable { } value = msg.use_tropo_grid_points; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.use_tropo_grid_points + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.use_tropo_grid_points + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest.java index a0d14325e..33244a0f8 100644 --- a/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest.java +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPointSatLos.yaml by generate.py. Do -// not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPointSatLos.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPointSatLos; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest { @@ -29,42 +33,16 @@ public class auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest.test1"); - byte[] payload = - new byte[] { - (byte) 180, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 3, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 0, - (byte) 5, - (byte) 0, - (byte) 6, - (byte) 30, - (byte) 0, - (byte) 2, - (byte) 10, - (byte) 11, - (byte) 15, - (byte) 14, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x0BD1, payload); - MsgSsrFlagIonoGridPointSatLos msg = new MsgSsrFlagIonoGridPointSatLos(sbp); + System.out.format("%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagIonoGridPointSatLosTest.test1"); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)0,(byte)5,(byte)0,(byte)6,(byte)30,(byte)0,(byte)2,(byte)10,(byte)11,(byte)15,(byte)14, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x0BD1, payload ); + MsgSsrFlagIonoGridPointSatLos msg = new MsgSsrFlagIonoGridPointSatLos( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.faulty_los[0].constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_los[0].constellation + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.faulty_los[0].constellation + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -72,9 +50,7 @@ public void test1() throws Throwable { } value = msg.faulty_los[0].satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_los[0].satId + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.faulty_los[0].satId + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -82,9 +58,7 @@ public void test1() throws Throwable { } value = msg.faulty_los[1].constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_los[1].constellation + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.faulty_los[1].constellation + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -92,9 +66,7 @@ public void test1() throws Throwable { } value = msg.faulty_los[1].satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_los[1].satId + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.faulty_los[1].satId + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -102,9 +74,7 @@ public void test1() throws Throwable { } value = msg.grid_point_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.grid_point_id + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.grid_point_id + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -112,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.chain_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.chain_id + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.header.chain_id + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -122,9 +90,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -132,9 +98,7 @@ public void test1() throws Throwable { } value = msg.header.obs_time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.obs_time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.header.obs_time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -142,9 +106,7 @@ public void test1() throws Throwable { } value = msg.header.obs_time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.obs_time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.obs_time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -152,9 +114,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -162,9 +122,7 @@ public void test1() throws Throwable { } value = msg.header.ssr_sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.ssr_sol_id + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.ssr_sol_id + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -172,9 +130,7 @@ public void test1() throws Throwable { } value = msg.header.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tile_id + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.header.tile_id + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -182,9 +138,7 @@ public void test1() throws Throwable { } value = msg.header.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tile_set_id + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.header.tile_set_id + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -192,9 +146,7 @@ public void test1() throws Throwable { } value = msg.n_faulty_los; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_faulty_los + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.n_faulty_los + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest.java index 51aa8b961..cf1cc6450 100644 --- a/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest.java +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPoints.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoGridPoints.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.integrity.MsgSsrFlagIonoGridPoints; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest { @@ -29,42 +33,16 @@ public class auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest.test1"); - byte[] payload = - new byte[] { - (byte) 180, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 3, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 0, - (byte) 5, - (byte) 0, - (byte) 6, - (byte) 3, - (byte) 10, - (byte) 0, - (byte) 11, - (byte) 0, - (byte) 12, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x0BC7, payload); - MsgSsrFlagIonoGridPoints msg = new MsgSsrFlagIonoGridPoints(sbp); + System.out.format("%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagIonoGridPointsTest.test1"); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)0,(byte)5,(byte)0,(byte)6,(byte)3,(byte)10,(byte)0,(byte)11,(byte)0,(byte)12,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x0BC7, payload ); + MsgSsrFlagIonoGridPoints msg = new MsgSsrFlagIonoGridPoints( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.faulty_points[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_points[0] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.faulty_points[0] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -72,9 +50,7 @@ public void test1() throws Throwable { } value = msg.faulty_points[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_points[1] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.faulty_points[1] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -82,9 +58,7 @@ public void test1() throws Throwable { } value = msg.faulty_points[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_points[2] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.faulty_points[2] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -92,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.chain_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.chain_id + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.header.chain_id + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -102,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -112,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.obs_time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.obs_time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.header.obs_time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -122,9 +90,7 @@ public void test1() throws Throwable { } value = msg.header.obs_time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.obs_time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.obs_time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -132,9 +98,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -142,9 +106,7 @@ public void test1() throws Throwable { } value = msg.header.ssr_sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.ssr_sol_id + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.ssr_sol_id + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -152,9 +114,7 @@ public void test1() throws Throwable { } value = msg.header.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tile_id + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.header.tile_id + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -162,9 +122,7 @@ public void test1() throws Throwable { } value = msg.header.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tile_set_id + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.header.tile_set_id + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -172,9 +130,7 @@ public void test1() throws Throwable { } value = msg.n_faulty_points; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_faulty_points + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.n_faulty_points + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest.java index 0ca4de5ab..421f3d9c5 100644 --- a/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest.java +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoTileSatLos.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagIonoTileSatLos.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.integrity.MsgSsrFlagIonoTileSatLos; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest { @@ -29,40 +33,16 @@ public class auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest.test1"); - byte[] payload = - new byte[] { - (byte) 180, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 3, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 0, - (byte) 5, - (byte) 0, - (byte) 6, - (byte) 2, - (byte) 10, - (byte) 11, - (byte) 15, - (byte) 14, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x0BCD, payload); - MsgSsrFlagIonoTileSatLos msg = new MsgSsrFlagIonoTileSatLos(sbp); + System.out.format("%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagIonoTileSatLosTest.test1"); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)0,(byte)5,(byte)0,(byte)6,(byte)2,(byte)10,(byte)11,(byte)15,(byte)14, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x0BCD, payload ); + MsgSsrFlagIonoTileSatLos msg = new MsgSsrFlagIonoTileSatLos( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.faulty_los[0].constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_los[0].constellation + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.faulty_los[0].constellation + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -70,9 +50,7 @@ public void test1() throws Throwable { } value = msg.faulty_los[0].satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_los[0].satId + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.faulty_los[0].satId + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -80,9 +58,7 @@ public void test1() throws Throwable { } value = msg.faulty_los[1].constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_los[1].constellation + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.faulty_los[1].constellation + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -90,9 +66,7 @@ public void test1() throws Throwable { } value = msg.faulty_los[1].satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_los[1].satId + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.faulty_los[1].satId + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -100,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.chain_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.chain_id + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.header.chain_id + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -110,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -120,9 +90,7 @@ public void test1() throws Throwable { } value = msg.header.obs_time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.obs_time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.header.obs_time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -130,9 +98,7 @@ public void test1() throws Throwable { } value = msg.header.obs_time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.obs_time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.obs_time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -140,9 +106,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -150,9 +114,7 @@ public void test1() throws Throwable { } value = msg.header.ssr_sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.ssr_sol_id + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.ssr_sol_id + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -160,9 +122,7 @@ public void test1() throws Throwable { } value = msg.header.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tile_id + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.header.tile_id + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -170,9 +130,7 @@ public void test1() throws Throwable { } value = msg.header.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tile_set_id + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.header.tile_set_id + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -180,9 +138,7 @@ public void test1() throws Throwable { } value = msg.n_faulty_los; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_faulty_los + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.n_faulty_los + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagSatellitesTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagSatellitesTest.java index 54ee4ed9a..5e4560918 100644 --- a/java/test/auto_check_sbp_integrity_MsgSsrFlagSatellitesTest.java +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagSatellitesTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagSatellites.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagSatellites.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.integrity.MsgSsrFlagSatellites; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_integrity_MsgSsrFlagSatellitesTest { @@ -30,21 +34,15 @@ public class auto_check_sbp_integrity_MsgSsrFlagSatellitesTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagSatellitesTest.test1"); - byte[] payload = - new byte[] { - (byte) 180, (byte) 0, (byte) 0, (byte) 0, (byte) 3, (byte) 0, (byte) 1, - (byte) 2, (byte) 3, (byte) 4, (byte) 5, (byte) 3, (byte) 10, (byte) 11, - (byte) 12, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x0BBD, payload); - MsgSsrFlagSatellites msg = new MsgSsrFlagSatellites(sbp); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)3,(byte)10,(byte)11,(byte)12, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x0BBD, payload ); + MsgSsrFlagSatellites msg = new MsgSsrFlagSatellites( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.chain_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.chain_id + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.chain_id + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -52,8 +50,7 @@ public void test1() throws Throwable { } value = msg.const_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.const_id + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.const_id + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -61,9 +58,7 @@ public void test1() throws Throwable { } value = msg.faulty_sats[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_sats[0] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.faulty_sats[0] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -71,9 +66,7 @@ public void test1() throws Throwable { } value = msg.faulty_sats[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_sats[1] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.faulty_sats[1] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -81,9 +74,7 @@ public void test1() throws Throwable { } value = msg.faulty_sats[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_sats[2] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.faulty_sats[2] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -91,9 +82,7 @@ public void test1() throws Throwable { } value = msg.n_faulty_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_faulty_sats + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.n_faulty_sats + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -101,8 +90,7 @@ public void test1() throws Throwable { } value = msg.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.num_msgs + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.num_msgs + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -110,9 +98,7 @@ public void test1() throws Throwable { } value = msg.obs_time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.obs_time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.obs_time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -120,9 +106,7 @@ public void test1() throws Throwable { } value = msg.obs_time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.obs_time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.obs_time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -130,8 +114,7 @@ public void test1() throws Throwable { } value = msg.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.seq_num + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.seq_num + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -139,9 +122,7 @@ public void test1() throws Throwable { } value = msg.ssr_sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ssr_sol_id + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.ssr_sol_id + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest.java index af90587bd..41174d443 100644 --- a/java/test/auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest.java +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagTropoGridPoints.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagTropoGridPoints.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.integrity.MsgSsrFlagTropoGridPoints; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest { @@ -29,42 +33,16 @@ public class auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest.test1"); - byte[] payload = - new byte[] { - (byte) 180, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 3, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 0, - (byte) 5, - (byte) 0, - (byte) 6, - (byte) 3, - (byte) 10, - (byte) 0, - (byte) 11, - (byte) 0, - (byte) 12, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x0BC3, payload); - MsgSsrFlagTropoGridPoints msg = new MsgSsrFlagTropoGridPoints(sbp); + System.out.format("%n%s%n", "auto_check_sbp_integrity_MsgSsrFlagTropoGridPointsTest.test1"); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)0,(byte)5,(byte)0,(byte)6,(byte)3,(byte)10,(byte)0,(byte)11,(byte)0,(byte)12,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x0BC3, payload ); + MsgSsrFlagTropoGridPoints msg = new MsgSsrFlagTropoGridPoints( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.faulty_points[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_points[0] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.faulty_points[0] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -72,9 +50,7 @@ public void test1() throws Throwable { } value = msg.faulty_points[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_points[1] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.faulty_points[1] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -82,9 +58,7 @@ public void test1() throws Throwable { } value = msg.faulty_points[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.faulty_points[2] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.faulty_points[2] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -92,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.chain_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.chain_id + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.header.chain_id + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -102,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -112,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.obs_time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.obs_time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.header.obs_time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -122,9 +90,7 @@ public void test1() throws Throwable { } value = msg.header.obs_time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.obs_time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.obs_time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -132,9 +98,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -142,9 +106,7 @@ public void test1() throws Throwable { } value = msg.header.ssr_sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.ssr_sol_id + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.ssr_sol_id + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -152,9 +114,7 @@ public void test1() throws Throwable { } value = msg.header.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tile_id + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.header.tile_id + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -162,9 +122,7 @@ public void test1() throws Throwable { } value = msg.header.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tile_set_id + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.header.tile_set_id + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -172,9 +130,7 @@ public void test1() throws Throwable { } value = msg.n_faulty_points; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_faulty_points + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.n_faulty_points + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; diff --git a/java/test/auto_check_sbp_integrity_integrity_structsTest.java b/java/test/auto_check_sbp_integrity_integrity_structsTest.java index a91ae18fd..8aff52e34 100644 --- a/java/test/auto_check_sbp_integrity_integrity_structsTest.java +++ b/java/test/auto_check_sbp_integrity_integrity_structsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,11 +9,19 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/integrity/test_integrity_structs.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/integrity/test_integrity_structs.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; + +import org.json.JSONObject; + +import com.swiftnav.sbp.SBPMessage; + public class auto_check_sbp_integrity_integrity_structsTest { diff --git a/java/test/auto_check_sbp_linux_MsgLinuxCpuStateDepATest.java b/java/test/auto_check_sbp_linux_MsgLinuxCpuStateDepATest.java index 4629c08bae53a1050c22d9578365ae03c648ce44..b9b669350d9aa51bbb5a47fedda1cc27d6fc29bf 100644 GIT binary patch delta 850 zcmeBBYm#Eo*Wyx`$SA>RxKZi|< zWRbi8x81-P>KPMQOc1FY7MRG&>mf0X4(6pZXUO;rRHeb}_S$yuC3Z{lW3YtK;`57M< z<78F=cP<5BiiC(we#RFxd5OS|$%TUIlMnDI@+g>@0FyA1q`J@qR-lnwT$2;|8Qb{vDuWqEQ6Ql?nCVpGZ?5ABURhMwPd!1ns!dT0LV+zwpd13Vv&{I_o3=|kNf zyI=b(Z!0_V@+$Qh5((jS3)J{-7C{}|DG zgNwfF{RXFq;rRg!+;cZTt-uGg+i4Qe)`RPe$;Y`f>b*gS_NhB?(JjVmBJ!CVc<2T& zXs}^uj{>)MF|bE4yciAru|r9kwIqx_hI0nkkD@thk{FsP{i;?o%}s;yl3#@i!c5DP zITI`msl2lk8;MFPVUbBT%3O!b*xWVRL@YDrBD>C|m*;9epkKWt8*4=9v&1&Y0w!zN z!5YchfW8DFH7wM|3=1 zE6tXM%(O9+DORsheIEB}@9Fu}z zS39L5P!jB}20=8TYvGf4$F&u=JFRkgw_I*L|E1L4vf35$PKCTY{ueLG&0FQ>menn{ zuaI}D%*(6y;(59E*0*I>?)+P%or=IKx?YvH^{k>UVJ~Wl^|Bw9r3#Y2} z-#GG5%WGfd-6|g}tM#;WFgxYT@PUIXUnUP5T*aT62M(@$A3ShycTD_EK_m)-2uQ(@ z5fO1H4jZlO?xYnRL+kqatkpW+F^&T&au;!gr6Mv$Sa*pV=;{EW;Eg~$5)IMZ(2~v@ z2YOz%oZx%QDvYx&#iKp4J!RKOxRHPtspY&h=bpC0*BEUe<-`x?Q-&O|@dfK4pV4xP zB$OdPGZSRHrj}-s$_N?si3pbr!gSuEn?<)a-Ja5|b4bnd@U}T{F=f|9L_`!fVlI%C ziipV>6pXrgz$q!SdlCrJjC~nC8Pt#J@N-_g+%bNyAHn0-kRNxg{5O)%JOqPn>QJ~h z@^gRI=vsqj^PuiGz>rk`E4W>n8?ac4`CIDCVZSJ(U0bjq2wRkbWcTE^ZBPz;yazap zXWzSB5Y)RQO0oj~$CaA=-mWx~-mfh+s(zPR6K+wA?@(-h@Sy#`TH_1Zt)YI_!8ep` zvG-F!>F%!0c-}wjIly;m!3O!iZbJDplkZL1RJg$o7uTalk7z~hD|8QvCwJSij%$Lz X@Lxq|DQ99DuRVlq?AF3f?WXn*O^BT+ diff --git a/java/test/auto_check_sbp_linux_MsgLinuxCpuStateTest.java b/java/test/auto_check_sbp_linux_MsgLinuxCpuStateTest.java index b6af0c6a8131c9f2c7d89dd6571c8c8b2ac10e99..db8b25b1b87eec80927c5fe0753c5acb8ca92718 100644 GIT binary patch delta 995 zcmeyT^F*FSUyDm&BBKPO;YO(=jFay&Hcw7w(wzK|Nmha@Gq)hWs6-*ZC|xhBG%vG6 zFC?|N#F}gJUnbef8<-?{f}H|3UEgAC2!M#7v5(*RTt zmo$Vq9!V0LCt=F4_^}@0H3W-PPa4B4Me+g6-G&CnP`{YKA`V%3Jv5>bQG!qp3r%G8 zxRsm2f|y93~Ra*FJpd{aaZD9NV; s&P-03>7IEdsp+Xj8VX9rmL?V!hNi}bmP%lo!M4m0oyw>%SywC&02w43KL7v# literal 5758 zcmeHLZExC05bkGw#T2Ou+$DY?aD`Ttj(~IZ9We-;_Nvnd|WN#uk}1#)L*SV$YfeDI1WT4|Mm=Puy*DS&8}<$8T759B)8Y86Ynww0@cC#w{9yKt zK2*CC{9c8Rru}|+Zo|j!c-*z@PcS^ixKHqxY4r~Y&Oira494H1u`!uo%EVbvtDhfz&XF(yPpRaVGo$ee1>PL}Iu?-jrgx zf-R&HuN3HWh`59Wp9S8EtaB%ty{uF!!Gf02-D)Q%qcbK1cJlUKpR5q&b`3lK&(6|O z7LJ@NCxLH9lKCvz8F}I>p9PPUKPN+Ln61#8wloT)Vy`)i(8nK zY+PhT+#!Mj;ajBwcx|Eu5`-XA&O_!zFk{oyhj-vPp}-z9$0S%HiLmkXg2)MB#xXgA zzA>=7=&rLPy@g{W|KBOgeu^az@cqDtdaaIcM#3)z4jcbC1o16%rNF?0T9&^Kla-Kc zq3~2H9#4?1TJ=@*O1z4yhft-Z@t{_-#idv4>pm#ObS2q8|3d7nLhj7q-7Ys7>5ACp z)+sM+ZCc-J1W^ZF)A3#V&b75S8pZZbtI*zQ7n&P-arkkuxzj90F9~mGh2gqh(z{-q zUe}Ac?R1LMmyM=`JH5o-Eaq0%i`nVCE~);s$Y=gqPw)Q(9dK ze94+Ch5vua-@h4_jb8h)C4XGZeOdOh-AFqwT$s(`o%)%JD`xh2i)$6{M$cSa@fq~Y z#eHYRU*{?(SE+zn5ak)En*3o+yK1*k0)Te)+SA&HTRF6+lWwb5SO`*ugmc?e!xVdw zxo`y%vKWM+isbaXw&!Q1iz)tES~_96(V4V=Y@V_!RQf3U^OiDUoQdDAz#mUiLCuSQ zjISvQ)!H2;MmgQZ3{@~g!KlV4w^hm2IN>hJ_oK*JFmMuIqnl2*2HlS7*4)>NS$Uft zywLGQUJbU9^{g~z9(#{vwIq_la$>pp8~1}Rroa{FH4M{s|WD%9b}Ii zTJ{~)a8`oC);#3tmF)S@t2MMiy}rl$H8526w~E`gxdsb)19-8jwh zpN?(Hdz0)=`=MNS+K)mt!sbjo0@K0XruKwH<1g?V8%RsjnvD(ByEl;9-Cpah;QoCj z19+4PtdSpc2r^jgojFf81RxKZi|P?+q>+c5bWuPvj(WMRI-$us#pxD?0e#EImn=}A1gIH< zhzBf@3??E^Lf}bpIN=e4y`J5%oRPH$S2G^WAkL*CyfK52OO^3)u2_gTQ-(kpTyZr+ z>y0xF%qRj;$cp47WK6Pb&O*we2<@Xif{xp@z;wD`J7?~&Z+f=t0G(mm3NY1BT-4FEYQhD>I*-P^mU_k#L^?4eLH`sx3j9n%D-^k0hi@D(VxZt7DXySvCi7Sb{#}A(%z7?uu$S2S!{5Lm8bUa!} z#bQn5N}GrbtJkQ%N?yrVNqrycG&Mh*dNF%Oy}8Vbu*VC<{{9D2e-Q~kgb%kIlS0C- z)=FidBv@Y!g23H%^adZrd#;uI@YWscD226v_o!G%1=%z#YU^z+%S%- z?RUtJcA2*-;ZLetW3(QZUA6PaNO#QCuCDLO+jw1BHltNNG&`f)0dG_f%})6LN4{d+ zJnhIIR@Z*#;8hQn(R$RfeCFV)m&x-6cU--Vo;kSceele|-81nwC66fiAs_=oLPWfw zJZ!YCUx(w9eP~_3ncyGGHR0G|BKPq|h$V3`!n#k~Kv!D`C2a(vk!XnKni6#0*wSXcn0-$wpjrdH6>f_j<~-(r-8j1xbse{-aWjXRu&d;n$*gg=73)--DMQpg2aNR~#VuEMm~uvJj9Og~X)wmU{ats8?SA>6VWBzz#nRgVhf{SCr)K%4fh zqoDSse5?IGuh{7JcBzf_;ag)>>`kDQ?)qAm?BNC!08i3_CGwLtA!c!j{}a1_e!pwO z$>EPqJiezqO}P=bEC#jz@e^N-P^?Z`R=C8rch`#-FKA0`#_<6ZN30iQ9Tx?G;XjMc TGR~4PS~v*XSnq|K+D+|0`=gy? diff --git a/java/test/auto_check_sbp_linux_MsgLinuxMemStateTest.java b/java/test/auto_check_sbp_linux_MsgLinuxMemStateTest.java index 978ceee2be6b0f9ca85d0d9990acab7508bdb483..6ebf944d0357d5a17b119839749f379774503946 100644 GIT binary patch delta 989 zcmeyT^F*FSUyDm&BBKPO;YO(=jFay&Hcw7w(wzK|Nmha@Gq)hWs6-*ZC|xhBG%vG6 zFC?|N#F}gJUnbef8<-?{f}H|sf=L>}%{Q!v zSzu`ilQn<|85)|x#NaFwgpdJL(h_Esp#i2DFh%Gz%hH!Tw3^If}+5qNMmrAU(4JPA{V#gFyW@T4)!QY0V1+-+z8iyRXRXn-LruZKo7B1#bIVWEkv9=CE+ zSP&Db91SecWbn4&PbiPxM}p*X2P zVe%f{hRMEswu}msyZ8zx3-G&hDwv!3C};xVWM846$?N!cPOcH~;8FmlbR=OJ!5x!d z3aU>w<5%QSFf}(aw}eP;_7&n~oSZN0#;ITk6#^T>BeG-iO%XkydOjs^Hgd{L_slCv gO;0V-P*5^9G`2J_H8(UdRzlc3Lv$+8Rk~t<04lT^00000 literal 5758 zcmeHLQE%Ev5biU-Vv1A+?h+f5P)e&xN5HxI4r~OZz3Oy|jJ*b@wwLp+Nl=ylelrGR zk~DUuHp$ER!2!?CH#6UicR!;30zJN5$NqdFq1LNIv!S()nvG@?CRe^E!L(QY+?GC% zz=#~B0^|@$+mUZ!A>~rMRaKEJmpqn=AdkpiDGm>DA+4P*d;x+dvBQ8qC9_NBNRS-l zfdM+n0~O%r|_ve9(T>@XRyxD?=$>qnEgY7({X`52K}$mSf5PL(;9;@91RS; ze~9S4!Fk^>e}_}VFs&&JjG-~bRZ|PlFI!1K+X#j}p%_Db-1~q5yQjv$z_6IBipXci z)Wk4=NkbP#-SO1uoe#QW7@dzt)%xxQmz7Gz4{40%v(u=gS4M zagio*j|g&vuayemwe=QA5Q5A&511W+%Vxr9 z^})1@%QbeSwXlt}{x^!UA7aIQd_VA^R;%Ni5%Vj7&Bi}AL3~Y@lB4fIEsbA?$y!Jj zDm;;j$75uxR(%z{60f4_AyjEJzN^%9xU_10QwN2ZttI>WA6VM!fZHy--^C^)T@ky= z7UhX;Oq+X+AnKsCPVim(#+BJSTA{t!JTA0rokDZ-q+Mul6{9y_7kX=NiqYF8?pm`L zUMt~FE9S0K%#GG4cGt94NqWWhlVY=`H45Q7#oTI*AFHl7_>WjiMouf~dRg6C$xt_d6R1u??%s@ zT=60D%*lOY;%{=5ldDufEr{}rR89V{*0}cEmUjq^>$ZpQUM7e3bkbe*3ZWoXNH}** zH4L%mnG07SA&XAvsz^@HYkTX=B%I-|rIj5dTb)V!$Mz|^Mx~FkKQAd2#;N%23jFaT z71X@=NB=iLp<27A#3-f{x~PH~3PyE_a$A*LUB=u&`F<4HAp<*}H|VC(tx30Ix}EIn z#WcNb4PIc+MV=9<)s5MYP#Q-L;~wOazP=}Hsj>$On8pdapFTNM532BMN?sZmKUWXn z<$FjUw_m5 zAR!2wQ$e-|>f1Ib1wPyX?B}!VU6us(&W~JnodY*0N*q IrgBsH57u6IY5)KL diff --git a/java/test/auto_check_sbp_linux_MsgLinuxProcessFdCountTest.java b/java/test/auto_check_sbp_linux_MsgLinuxProcessFdCountTest.java index 9edc822b0..abe6d190b 100644 --- a/java/test/auto_check_sbp_linux_MsgLinuxProcessFdCountTest.java +++ b/java/test/auto_check_sbp_linux_MsgLinuxProcessFdCountTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/linux/test_MsgLinuxProcessFdCount.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/linux/test_MsgLinuxProcessFdCount.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.linux.MsgLinuxProcessFdCount; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_linux_MsgLinuxProcessFdCountTest { @@ -30,72 +34,16 @@ public class auto_check_sbp_linux_MsgLinuxProcessFdCountTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_linux_MsgLinuxProcessFdCountTest.test1"); - byte[] payload = - new byte[] { - (byte) 164, - (byte) 189, - (byte) 165, - (byte) 5, - (byte) 139, - (byte) 47, - (byte) 112, - (byte) 97, - (byte) 116, - (byte) 104, - (byte) 47, - (byte) 116, - (byte) 111, - (byte) 47, - (byte) 112, - (byte) 114, - (byte) 111, - (byte) 99, - (byte) 101, - (byte) 115, - (byte) 115, - (byte) 45, - (byte) 110, - (byte) 97, - (byte) 109, - (byte) 101, - (byte) 32, - (byte) 97, - (byte) 114, - (byte) 103, - (byte) 48, - (byte) 32, - (byte) 97, - (byte) 114, - (byte) 103, - (byte) 49, - (byte) 32, - (byte) 97, - (byte) 114, - (byte) 103, - (byte) 50, - (byte) 32, - (byte) 97, - (byte) 114, - (byte) 103, - (byte) 51, - (byte) 32, - (byte) 97, - (byte) 114, - (byte) 103, - (byte) 52, - }; - SBPMessage sbp = new SBPMessage(0xc31e, 0x7f06, payload); - MsgLinuxProcessFdCount msg = new MsgLinuxProcessFdCount(sbp); + byte[] payload = new byte[] {(byte)164,(byte)189,(byte)165,(byte)5,(byte)139,(byte)47,(byte)112,(byte)97,(byte)116,(byte)104,(byte)47,(byte)116,(byte)111,(byte)47,(byte)112,(byte)114,(byte)111,(byte)99,(byte)101,(byte)115,(byte)115,(byte)45,(byte)110,(byte)97,(byte)109,(byte)101,(byte)32,(byte)97,(byte)114,(byte)103,(byte)48,(byte)32,(byte)97,(byte)114,(byte)103,(byte)49,(byte)32,(byte)97,(byte)114,(byte)103,(byte)50,(byte)32,(byte)97,(byte)114,(byte)103,(byte)51,(byte)32,(byte)97,(byte)114,(byte)103,(byte)52, }; + SBPMessage sbp = new SBPMessage( 0xc31e, 0x7f06, payload ); + MsgLinuxProcessFdCount msg = new MsgLinuxProcessFdCount( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; - org.junit.Assert.assertEquals( - msg.cmdline, "/path/to/process-name arg0 arg1 arg2 arg3 arg4"); + org.junit.Assert.assertEquals(msg.cmdline, "/path/to/process-name arg0 arg1 arg2 arg3 arg4" ); value = msg.fd_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fd_count + "' != '" + 35589 + "'", - value.equals(BigInteger.valueOf(35589L))); + org.junit.Assert.assertTrue("'" + msg.fd_count + "' != '" + 35589 + "'", value.equals(BigInteger.valueOf( 35589L ) ) ); } else { value = value.longValue(); expected = 35589L; @@ -103,8 +51,7 @@ public void test1() throws Throwable { } value = msg.index; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.index + "' != '" + 164 + "'", value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.index + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -112,9 +59,7 @@ public void test1() throws Throwable { } value = msg.pid; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pid + "' != '" + 42429 + "'", - value.equals(BigInteger.valueOf(42429L))); + org.junit.Assert.assertTrue("'" + msg.pid + "' != '" + 42429 + "'", value.equals(BigInteger.valueOf( 42429L ) ) ); } else { value = value.longValue(); expected = 42429L; diff --git a/java/test/auto_check_sbp_linux_MsgLinuxProcessFdSummaryTest.java b/java/test/auto_check_sbp_linux_MsgLinuxProcessFdSummaryTest.java index bdee15b2eaaa58af77b827bb5c0b15d5f4a0ec97..2758878df7498784839770dcdb09a0c245c0d44d 100644 GIT binary patch delta 463 zcmZ22d|r@6UyDm&BBKPO;YO(=jFay&x=vPQiq%)h%}>cpt5is;RLDroOHt(F%FHdu zFDg;UN-Rs%%S|lF&~wU6_slCvO;0Vd=9;X-EIC<_S!VKXCdtVgn0SD+>%yodYd71%`E=a7* z$xlpCn7oh8omHVYsX$>e2m2aEg~?mkD<(T~m`?8EP!v=!G&V4?v@kQaF!xc=1j5NX HI6eaaQ3Qu) delta 742 zcmX>vxLR0BUrWI`zo4=xGd-h3LBm;7!N|bSRM*JB$Y`VN5yr`n7+sjT^z|pJF~y1i zX@%VUl+3hBg``S_jKsVYMXt%*%uc_#BRTgYVQ7UUO|C}bs;CFcE-ChH$o#fdQOtZVqP}8W4Re1XF|(1Pfg;PAlqx zJ~2hO9=8cFznUWafvOm%6`-&}3KUagct8LRh=PSCj_@%xK~jy+3ImK_oV=e^N70}n z&B6>A4F(nFX$C;LAh9whKQTqq8fMmHLpI6D>TD{^#YqK|1K8F~{>xS&3X?=h8k0-e fO+~QDOkTyV$ZKe9U}9-uW^7^Zqp3Oh4*O>SYQVCU diff --git a/java/test/auto_check_sbp_linux_MsgLinuxProcessSocketCountsTest.java b/java/test/auto_check_sbp_linux_MsgLinuxProcessSocketCountsTest.java index 0733e831e..00aa315fe 100644 --- a/java/test/auto_check_sbp_linux_MsgLinuxProcessSocketCountsTest.java +++ b/java/test/auto_check_sbp_linux_MsgLinuxProcessSocketCountsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/linux/test_MsgLinuxProcessSocketCounts.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/linux/test_MsgLinuxProcessSocketCounts.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.linux.MsgLinuxProcessSocketCounts; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_linux_MsgLinuxProcessSocketCountsTest { @@ -29,77 +33,17 @@ public class auto_check_sbp_linux_MsgLinuxProcessSocketCountsTest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_linux_MsgLinuxProcessSocketCountsTest.test1"); - byte[] payload = - new byte[] { - (byte) 51, - (byte) 137, - (byte) 111, - (byte) 79, - (byte) 118, - (byte) 3, - (byte) 140, - (byte) 114, - (byte) 115, - (byte) 47, - (byte) 112, - (byte) 97, - (byte) 116, - (byte) 104, - (byte) 47, - (byte) 116, - (byte) 111, - (byte) 47, - (byte) 112, - (byte) 114, - (byte) 111, - (byte) 99, - (byte) 101, - (byte) 115, - (byte) 115, - (byte) 45, - (byte) 110, - (byte) 97, - (byte) 109, - (byte) 101, - (byte) 32, - (byte) 97, - (byte) 114, - (byte) 103, - (byte) 48, - (byte) 32, - (byte) 97, - (byte) 114, - (byte) 103, - (byte) 49, - (byte) 32, - (byte) 97, - (byte) 114, - (byte) 103, - (byte) 50, - (byte) 32, - (byte) 97, - (byte) 114, - (byte) 103, - (byte) 51, - (byte) 32, - (byte) 97, - (byte) 114, - (byte) 103, - (byte) 52, - }; - SBPMessage sbp = new SBPMessage(0x096c, 0x7f03, payload); - MsgLinuxProcessSocketCounts msg = new MsgLinuxProcessSocketCounts(sbp); + System.out.format("%n%s%n", "auto_check_sbp_linux_MsgLinuxProcessSocketCountsTest.test1"); + byte[] payload = new byte[] {(byte)51,(byte)137,(byte)111,(byte)79,(byte)118,(byte)3,(byte)140,(byte)114,(byte)115,(byte)47,(byte)112,(byte)97,(byte)116,(byte)104,(byte)47,(byte)116,(byte)111,(byte)47,(byte)112,(byte)114,(byte)111,(byte)99,(byte)101,(byte)115,(byte)115,(byte)45,(byte)110,(byte)97,(byte)109,(byte)101,(byte)32,(byte)97,(byte)114,(byte)103,(byte)48,(byte)32,(byte)97,(byte)114,(byte)103,(byte)49,(byte)32,(byte)97,(byte)114,(byte)103,(byte)50,(byte)32,(byte)97,(byte)114,(byte)103,(byte)51,(byte)32,(byte)97,(byte)114,(byte)103,(byte)52, }; + SBPMessage sbp = new SBPMessage( 0x096c, 0x7f03, payload ); + MsgLinuxProcessSocketCounts msg = new MsgLinuxProcessSocketCounts( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; - org.junit.Assert.assertEquals( - msg.cmdline, "/path/to/process-name arg0 arg1 arg2 arg3 arg4"); + org.junit.Assert.assertEquals(msg.cmdline, "/path/to/process-name arg0 arg1 arg2 arg3 arg4" ); value = msg.index; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.index + "' != '" + 51 + "'", value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.index + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -107,9 +51,7 @@ public void test1() throws Throwable { } value = msg.pid; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pid + "' != '" + 28553 + "'", - value.equals(BigInteger.valueOf(28553L))); + org.junit.Assert.assertTrue("'" + msg.pid + "' != '" + 28553 + "'", value.equals(BigInteger.valueOf( 28553L ) ) ); } else { value = value.longValue(); expected = 28553L; @@ -117,9 +59,7 @@ public void test1() throws Throwable { } value = msg.socket_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_count + "' != '" + 30287 + "'", - value.equals(BigInteger.valueOf(30287L))); + org.junit.Assert.assertTrue("'" + msg.socket_count + "' != '" + 30287 + "'", value.equals(BigInteger.valueOf( 30287L ) ) ); } else { value = value.longValue(); expected = 30287L; @@ -127,9 +67,7 @@ public void test1() throws Throwable { } value = msg.socket_states; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_states + "' != '" + 29554 + "'", - value.equals(BigInteger.valueOf(29554L))); + org.junit.Assert.assertTrue("'" + msg.socket_states + "' != '" + 29554 + "'", value.equals(BigInteger.valueOf( 29554L ) ) ); } else { value = value.longValue(); expected = 29554L; @@ -137,9 +75,7 @@ public void test1() throws Throwable { } value = msg.socket_types; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_types + "' != '" + 35843 + "'", - value.equals(BigInteger.valueOf(35843L))); + org.junit.Assert.assertTrue("'" + msg.socket_types + "' != '" + 35843 + "'", value.equals(BigInteger.valueOf( 35843L ) ) ); } else { value = value.longValue(); expected = 35843L; diff --git a/java/test/auto_check_sbp_linux_MsgLinuxProcessSocketQueuesTest.java b/java/test/auto_check_sbp_linux_MsgLinuxProcessSocketQueuesTest.java index f662c69f2ce0ec4ba664afb71160600de3ae5347..e3cbb5a82eb03ea3fad25aebe45c6893988c77b9 100644 GIT binary patch literal 5037 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 diff --git a/java/test/auto_check_sbp_linux_MsgLinuxSocketUsageTest.java b/java/test/auto_check_sbp_linux_MsgLinuxSocketUsageTest.java index f86b15ae8..08ee83c52 100644 --- a/java/test/auto_check_sbp_linux_MsgLinuxSocketUsageTest.java +++ b/java/test/auto_check_sbp_linux_MsgLinuxSocketUsageTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/linux/test_MsgLinuxSocketUsage.yaml by generate.py. Do not modify by -// hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/linux/test_MsgLinuxSocketUsage.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.linux.MsgLinuxSocketUsage; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_linux_MsgLinuxSocketUsageTest { @@ -30,91 +34,15 @@ public class auto_check_sbp_linux_MsgLinuxSocketUsageTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_linux_MsgLinuxSocketUsageTest.test1"); - byte[] payload = - new byte[] { - (byte) 13, - (byte) 196, - (byte) 69, - (byte) 173, - (byte) 67, - (byte) 222, - (byte) 186, - (byte) 181, - (byte) 246, - (byte) 154, - (byte) 251, - (byte) 17, - (byte) 224, - (byte) 179, - (byte) 26, - (byte) 169, - (byte) 177, - (byte) 90, - (byte) 149, - (byte) 213, - (byte) 214, - (byte) 6, - (byte) 126, - (byte) 64, - (byte) 120, - (byte) 185, - (byte) 84, - (byte) 131, - (byte) 200, - (byte) 111, - (byte) 32, - (byte) 141, - (byte) 217, - (byte) 209, - (byte) 52, - (byte) 14, - (byte) 190, - (byte) 147, - (byte) 159, - (byte) 246, - (byte) 141, - (byte) 122, - (byte) 212, - (byte) 119, - (byte) 131, - (byte) 30, - (byte) 120, - (byte) 47, - (byte) 25, - (byte) 109, - (byte) 154, - (byte) 65, - (byte) 132, - (byte) 164, - (byte) 39, - (byte) 30, - (byte) 30, - (byte) 175, - (byte) 8, - (byte) 44, - (byte) 28, - (byte) 111, - (byte) 236, - (byte) 240, - (byte) 176, - (byte) 74, - (byte) 159, - (byte) 129, - (byte) 154, - (byte) 153, - (byte) 162, - (byte) 229, - }; - SBPMessage sbp = new SBPMessage(0x8a72, 0x7f05, payload); - MsgLinuxSocketUsage msg = new MsgLinuxSocketUsage(sbp); + byte[] payload = new byte[] {(byte)13,(byte)196,(byte)69,(byte)173,(byte)67,(byte)222,(byte)186,(byte)181,(byte)246,(byte)154,(byte)251,(byte)17,(byte)224,(byte)179,(byte)26,(byte)169,(byte)177,(byte)90,(byte)149,(byte)213,(byte)214,(byte)6,(byte)126,(byte)64,(byte)120,(byte)185,(byte)84,(byte)131,(byte)200,(byte)111,(byte)32,(byte)141,(byte)217,(byte)209,(byte)52,(byte)14,(byte)190,(byte)147,(byte)159,(byte)246,(byte)141,(byte)122,(byte)212,(byte)119,(byte)131,(byte)30,(byte)120,(byte)47,(byte)25,(byte)109,(byte)154,(byte)65,(byte)132,(byte)164,(byte)39,(byte)30,(byte)30,(byte)175,(byte)8,(byte)44,(byte)28,(byte)111,(byte)236,(byte)240,(byte)176,(byte)74,(byte)159,(byte)129,(byte)154,(byte)153,(byte)162,(byte)229, }; + SBPMessage sbp = new SBPMessage( 0x8a72, 0x7f05, payload ); + MsgLinuxSocketUsage msg = new MsgLinuxSocketUsage( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.avg_queue_depth; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.avg_queue_depth + "' != '" + 2907030541L + "'", - value.equals(new BigInteger("2907030541"))); + org.junit.Assert.assertTrue("'" + msg.avg_queue_depth + "' != '" + 2907030541L + "'", value.equals( new BigInteger( "2907030541" ) ) ); } else { value = value.longValue(); expected = 2907030541L; @@ -122,9 +50,7 @@ public void test1() throws Throwable { } value = msg.max_queue_depth; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.max_queue_depth + "' != '" + 3048922691L + "'", - value.equals(new BigInteger("3048922691"))); + org.junit.Assert.assertTrue("'" + msg.max_queue_depth + "' != '" + 3048922691L + "'", value.equals( new BigInteger( "3048922691" ) ) ); } else { value = value.longValue(); expected = 3048922691L; @@ -132,9 +58,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[0] + "' != '" + 39670 + "'", - value.equals(BigInteger.valueOf(39670L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[0] + "' != '" + 39670 + "'", value.equals(BigInteger.valueOf( 39670L ) ) ); } else { value = value.longValue(); expected = 39670L; @@ -142,9 +66,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[1] + "' != '" + 4603 + "'", - value.equals(BigInteger.valueOf(4603L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[1] + "' != '" + 4603 + "'", value.equals(BigInteger.valueOf( 4603L ) ) ); } else { value = value.longValue(); expected = 4603L; @@ -152,9 +74,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[2] + "' != '" + 46048 + "'", - value.equals(BigInteger.valueOf(46048L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[2] + "' != '" + 46048 + "'", value.equals(BigInteger.valueOf( 46048L ) ) ); } else { value = value.longValue(); expected = 46048L; @@ -162,9 +82,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[3] + "' != '" + 43290 + "'", - value.equals(BigInteger.valueOf(43290L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[3] + "' != '" + 43290 + "'", value.equals(BigInteger.valueOf( 43290L ) ) ); } else { value = value.longValue(); expected = 43290L; @@ -172,9 +90,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[4] + "' != '" + 23217 + "'", - value.equals(BigInteger.valueOf(23217L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[4] + "' != '" + 23217 + "'", value.equals(BigInteger.valueOf( 23217L ) ) ); } else { value = value.longValue(); expected = 23217L; @@ -182,9 +98,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[5] + "' != '" + 54677 + "'", - value.equals(BigInteger.valueOf(54677L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[5] + "' != '" + 54677 + "'", value.equals(BigInteger.valueOf( 54677L ) ) ); } else { value = value.longValue(); expected = 54677L; @@ -192,9 +106,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[6] + "' != '" + 1750 + "'", - value.equals(BigInteger.valueOf(1750L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[6] + "' != '" + 1750 + "'", value.equals(BigInteger.valueOf( 1750L ) ) ); } else { value = value.longValue(); expected = 1750L; @@ -202,9 +114,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[7] + "' != '" + 16510 + "'", - value.equals(BigInteger.valueOf(16510L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[7] + "' != '" + 16510 + "'", value.equals(BigInteger.valueOf( 16510L ) ) ); } else { value = value.longValue(); expected = 16510L; @@ -212,9 +122,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[8] + "' != '" + 47480 + "'", - value.equals(BigInteger.valueOf(47480L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[8] + "' != '" + 47480 + "'", value.equals(BigInteger.valueOf( 47480L ) ) ); } else { value = value.longValue(); expected = 47480L; @@ -222,9 +130,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[9] + "' != '" + 33620 + "'", - value.equals(BigInteger.valueOf(33620L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[9] + "' != '" + 33620 + "'", value.equals(BigInteger.valueOf( 33620L ) ) ); } else { value = value.longValue(); expected = 33620L; @@ -232,9 +138,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[10] + "' != '" + 28616 + "'", - value.equals(BigInteger.valueOf(28616L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[10] + "' != '" + 28616 + "'", value.equals(BigInteger.valueOf( 28616L ) ) ); } else { value = value.longValue(); expected = 28616L; @@ -242,9 +146,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[11] + "' != '" + 36128 + "'", - value.equals(BigInteger.valueOf(36128L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[11] + "' != '" + 36128 + "'", value.equals(BigInteger.valueOf( 36128L ) ) ); } else { value = value.longValue(); expected = 36128L; @@ -252,9 +154,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[12] + "' != '" + 53721 + "'", - value.equals(BigInteger.valueOf(53721L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[12] + "' != '" + 53721 + "'", value.equals(BigInteger.valueOf( 53721L ) ) ); } else { value = value.longValue(); expected = 53721L; @@ -262,9 +162,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[13] + "' != '" + 3636 + "'", - value.equals(BigInteger.valueOf(3636L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[13] + "' != '" + 3636 + "'", value.equals(BigInteger.valueOf( 3636L ) ) ); } else { value = value.longValue(); expected = 3636L; @@ -272,9 +170,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[14] + "' != '" + 37822 + "'", - value.equals(BigInteger.valueOf(37822L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[14] + "' != '" + 37822 + "'", value.equals(BigInteger.valueOf( 37822L ) ) ); } else { value = value.longValue(); expected = 37822L; @@ -282,9 +178,7 @@ public void test1() throws Throwable { } value = msg.socket_state_counts[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_state_counts[15] + "' != '" + 63135 + "'", - value.equals(BigInteger.valueOf(63135L))); + org.junit.Assert.assertTrue("'" + msg.socket_state_counts[15] + "' != '" + 63135 + "'", value.equals(BigInteger.valueOf( 63135L ) ) ); } else { value = value.longValue(); expected = 63135L; @@ -292,9 +186,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[0] + "' != '" + 31373 + "'", - value.equals(BigInteger.valueOf(31373L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[0] + "' != '" + 31373 + "'", value.equals(BigInteger.valueOf( 31373L ) ) ); } else { value = value.longValue(); expected = 31373L; @@ -302,9 +194,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[1] + "' != '" + 30676 + "'", - value.equals(BigInteger.valueOf(30676L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[1] + "' != '" + 30676 + "'", value.equals(BigInteger.valueOf( 30676L ) ) ); } else { value = value.longValue(); expected = 30676L; @@ -312,9 +202,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[2] + "' != '" + 7811 + "'", - value.equals(BigInteger.valueOf(7811L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[2] + "' != '" + 7811 + "'", value.equals(BigInteger.valueOf( 7811L ) ) ); } else { value = value.longValue(); expected = 7811L; @@ -322,9 +210,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[3] + "' != '" + 12152 + "'", - value.equals(BigInteger.valueOf(12152L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[3] + "' != '" + 12152 + "'", value.equals(BigInteger.valueOf( 12152L ) ) ); } else { value = value.longValue(); expected = 12152L; @@ -332,9 +218,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[4] + "' != '" + 27929 + "'", - value.equals(BigInteger.valueOf(27929L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[4] + "' != '" + 27929 + "'", value.equals(BigInteger.valueOf( 27929L ) ) ); } else { value = value.longValue(); expected = 27929L; @@ -342,9 +226,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[5] + "' != '" + 16794 + "'", - value.equals(BigInteger.valueOf(16794L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[5] + "' != '" + 16794 + "'", value.equals(BigInteger.valueOf( 16794L ) ) ); } else { value = value.longValue(); expected = 16794L; @@ -352,9 +234,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[6] + "' != '" + 42116 + "'", - value.equals(BigInteger.valueOf(42116L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[6] + "' != '" + 42116 + "'", value.equals(BigInteger.valueOf( 42116L ) ) ); } else { value = value.longValue(); expected = 42116L; @@ -362,9 +242,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[7] + "' != '" + 7719 + "'", - value.equals(BigInteger.valueOf(7719L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[7] + "' != '" + 7719 + "'", value.equals(BigInteger.valueOf( 7719L ) ) ); } else { value = value.longValue(); expected = 7719L; @@ -372,9 +250,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[8] + "' != '" + 44830 + "'", - value.equals(BigInteger.valueOf(44830L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[8] + "' != '" + 44830 + "'", value.equals(BigInteger.valueOf( 44830L ) ) ); } else { value = value.longValue(); expected = 44830L; @@ -382,9 +258,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[9] + "' != '" + 11272 + "'", - value.equals(BigInteger.valueOf(11272L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[9] + "' != '" + 11272 + "'", value.equals(BigInteger.valueOf( 11272L ) ) ); } else { value = value.longValue(); expected = 11272L; @@ -392,9 +266,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[10] + "' != '" + 28444 + "'", - value.equals(BigInteger.valueOf(28444L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[10] + "' != '" + 28444 + "'", value.equals(BigInteger.valueOf( 28444L ) ) ); } else { value = value.longValue(); expected = 28444L; @@ -402,9 +274,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[11] + "' != '" + 61676 + "'", - value.equals(BigInteger.valueOf(61676L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[11] + "' != '" + 61676 + "'", value.equals(BigInteger.valueOf( 61676L ) ) ); } else { value = value.longValue(); expected = 61676L; @@ -412,9 +282,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[12] + "' != '" + 19120 + "'", - value.equals(BigInteger.valueOf(19120L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[12] + "' != '" + 19120 + "'", value.equals(BigInteger.valueOf( 19120L ) ) ); } else { value = value.longValue(); expected = 19120L; @@ -422,9 +290,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[13] + "' != '" + 33183 + "'", - value.equals(BigInteger.valueOf(33183L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[13] + "' != '" + 33183 + "'", value.equals(BigInteger.valueOf( 33183L ) ) ); } else { value = value.longValue(); expected = 33183L; @@ -432,9 +298,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[14] + "' != '" + 39322 + "'", - value.equals(BigInteger.valueOf(39322L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[14] + "' != '" + 39322 + "'", value.equals(BigInteger.valueOf( 39322L ) ) ); } else { value = value.longValue(); expected = 39322L; @@ -442,9 +306,7 @@ public void test1() throws Throwable { } value = msg.socket_type_counts[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.socket_type_counts[15] + "' != '" + 58786 + "'", - value.equals(BigInteger.valueOf(58786L))); + org.junit.Assert.assertTrue("'" + msg.socket_type_counts[15] + "' != '" + 58786 + "'", value.equals(BigInteger.valueOf( 58786L ) ) ); } else { value = value.longValue(); expected = 58786L; diff --git a/java/test/auto_check_sbp_linux_MsgLinuxSysStateDepATest.java b/java/test/auto_check_sbp_linux_MsgLinuxSysStateDepATest.java index f0a8491b5..1b0a71362 100644 --- a/java/test/auto_check_sbp_linux_MsgLinuxSysStateDepATest.java +++ b/java/test/auto_check_sbp_linux_MsgLinuxSysStateDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/linux/test_MsgLinuxSysStateDepA.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/linux/test_MsgLinuxSysStateDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.linux.MsgLinuxSysStateDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_linux_MsgLinuxSysStateDepATest { @@ -30,29 +34,15 @@ public class auto_check_sbp_linux_MsgLinuxSysStateDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_linux_MsgLinuxSysStateDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 188, - (byte) 163, - (byte) 211, - (byte) 194, - (byte) 115, - (byte) 71, - (byte) 101, - (byte) 103, - (byte) 124, - (byte) 201, - }; - SBPMessage sbp = new SBPMessage(0x3854, 0x7f02, payload); - MsgLinuxSysStateDepA msg = new MsgLinuxSysStateDepA(sbp); + byte[] payload = new byte[] {(byte)188,(byte)163,(byte)211,(byte)194,(byte)115,(byte)71,(byte)101,(byte)103,(byte)124,(byte)201, }; + SBPMessage sbp = new SBPMessage( 0x3854, 0x7f02, payload ); + MsgLinuxSysStateDepA msg = new MsgLinuxSysStateDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.mem_total; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.mem_total + "' != '" + 41916 + "'", - value.equals(BigInteger.valueOf(41916L))); + org.junit.Assert.assertTrue("'" + msg.mem_total + "' != '" + 41916 + "'", value.equals(BigInteger.valueOf( 41916L ) ) ); } else { value = value.longValue(); expected = 41916L; @@ -60,8 +50,7 @@ public void test1() throws Throwable { } value = msg.pcpu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pcpu + "' != '" + 211 + "'", value.equals(BigInteger.valueOf(211L))); + org.junit.Assert.assertTrue("'" + msg.pcpu + "' != '" + 211 + "'", value.equals(BigInteger.valueOf( 211L ) ) ); } else { value = value.longValue(); expected = 211L; @@ -69,9 +58,7 @@ public void test1() throws Throwable { } value = msg.pid_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pid_count + "' != '" + 51580 + "'", - value.equals(BigInteger.valueOf(51580L))); + org.junit.Assert.assertTrue("'" + msg.pid_count + "' != '" + 51580 + "'", value.equals(BigInteger.valueOf( 51580L ) ) ); } else { value = value.longValue(); expected = 51580L; @@ -79,8 +66,7 @@ public void test1() throws Throwable { } value = msg.pmem; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pmem + "' != '" + 194 + "'", value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.pmem + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -88,9 +74,7 @@ public void test1() throws Throwable { } value = msg.procs_starting; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.procs_starting + "' != '" + 18291 + "'", - value.equals(BigInteger.valueOf(18291L))); + org.junit.Assert.assertTrue("'" + msg.procs_starting + "' != '" + 18291 + "'", value.equals(BigInteger.valueOf( 18291L ) ) ); } else { value = value.longValue(); expected = 18291L; @@ -98,9 +82,7 @@ public void test1() throws Throwable { } value = msg.procs_stopping; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.procs_stopping + "' != '" + 26469 + "'", - value.equals(BigInteger.valueOf(26469L))); + org.junit.Assert.assertTrue("'" + msg.procs_stopping + "' != '" + 26469 + "'", value.equals(BigInteger.valueOf( 26469L ) ) ); } else { value = value.longValue(); expected = 26469L; diff --git a/java/test/auto_check_sbp_linux_MsgLinuxSysStateTest.java b/java/test/auto_check_sbp_linux_MsgLinuxSysStateTest.java index f8bcfe0bf..5d72e977b 100644 --- a/java/test/auto_check_sbp_linux_MsgLinuxSysStateTest.java +++ b/java/test/auto_check_sbp_linux_MsgLinuxSysStateTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/linux/test_MsgLinuxSysState.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/linux/test_MsgLinuxSysState.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.linux.MsgLinuxSysState; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_linux_MsgLinuxSysStateTest { @@ -27,22 +32,17 @@ public class auto_check_sbp_linux_MsgLinuxSysStateTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_linux_MsgLinuxSysStateTest.test1"); - byte[] payload = - new byte[] { - (byte) 20, (byte) 207, (byte) 125, (byte) 215, (byte) 196, (byte) 71, - (byte) 161, (byte) 229, (byte) 250, (byte) 186, (byte) 108, (byte) 30, - (byte) 106, (byte) 5, (byte) 9, - }; - SBPMessage sbp = new SBPMessage(0xa755, 0x7f0a, payload); - MsgLinuxSysState msg = new MsgLinuxSysState(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_linux_MsgLinuxSysStateTest.test1"); + byte[] payload = new byte[] {(byte)20,(byte)207,(byte)125,(byte)215,(byte)196,(byte)71,(byte)161,(byte)229,(byte)250,(byte)186,(byte)108,(byte)30,(byte)106,(byte)5,(byte)9, }; + SBPMessage sbp = new SBPMessage( 0xa755, 0x7f0a, payload ); + MsgLinuxSysState msg = new MsgLinuxSysState( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -50,9 +50,7 @@ public void test1() throws Throwable { } value = msg.mem_total; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.mem_total + "' != '" + 53012 + "'", - value.equals(BigInteger.valueOf(53012L))); + org.junit.Assert.assertTrue("'" + msg.mem_total + "' != '" + 53012 + "'", value.equals(BigInteger.valueOf( 53012L ) ) ); } else { value = value.longValue(); expected = 53012L; @@ -60,8 +58,7 @@ public void test1() throws Throwable { } value = msg.pcpu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pcpu + "' != '" + 125 + "'", value.equals(BigInteger.valueOf(125L))); + org.junit.Assert.assertTrue("'" + msg.pcpu + "' != '" + 125 + "'", value.equals(BigInteger.valueOf( 125L ) ) ); } else { value = value.longValue(); expected = 125L; @@ -69,9 +66,7 @@ public void test1() throws Throwable { } value = msg.pid_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pid_count + "' != '" + 47866 + "'", - value.equals(BigInteger.valueOf(47866L))); + org.junit.Assert.assertTrue("'" + msg.pid_count + "' != '" + 47866 + "'", value.equals(BigInteger.valueOf( 47866L ) ) ); } else { value = value.longValue(); expected = 47866L; @@ -79,8 +74,7 @@ public void test1() throws Throwable { } value = msg.pmem; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pmem + "' != '" + 215 + "'", value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.pmem + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -88,9 +82,7 @@ public void test1() throws Throwable { } value = msg.procs_starting; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.procs_starting + "' != '" + 18372 + "'", - value.equals(BigInteger.valueOf(18372L))); + org.junit.Assert.assertTrue("'" + msg.procs_starting + "' != '" + 18372 + "'", value.equals(BigInteger.valueOf( 18372L ) ) ); } else { value = value.longValue(); expected = 18372L; @@ -98,9 +90,7 @@ public void test1() throws Throwable { } value = msg.procs_stopping; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.procs_stopping + "' != '" + 58785 + "'", - value.equals(BigInteger.valueOf(58785L))); + org.junit.Assert.assertTrue("'" + msg.procs_stopping + "' != '" + 58785 + "'", value.equals(BigInteger.valueOf( 58785L ) ) ); } else { value = value.longValue(); expected = 58785L; @@ -108,9 +98,7 @@ public void test1() throws Throwable { } value = msg.time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time + "' != '" + 90840684 + "'", - value.equals(BigInteger.valueOf(90840684L))); + org.junit.Assert.assertTrue("'" + msg.time + "' != '" + 90840684 + "'", value.equals(BigInteger.valueOf( 90840684L ) ) ); } else { value = value.longValue(); expected = 90840684L; diff --git a/java/test/auto_check_sbp_logging_MsgFwdTest.java b/java/test/auto_check_sbp_logging_MsgFwdTest.java index bef711e50..dadf2494a 100644 --- a/java/test/auto_check_sbp_logging_MsgFwdTest.java +++ b/java/test/auto_check_sbp_logging_MsgFwdTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/logging/test_MsgFwd.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/logging/test_MsgFwd.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.logging.MsgFwd; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_logging_MsgFwdTest { @@ -27,23 +32,17 @@ public class auto_check_sbp_logging_MsgFwdTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_logging_MsgFwdTest.test1"); - byte[] payload = - new byte[] { - (byte) 0, (byte) 0, (byte) 86, (byte) 81, (byte) 68, (byte) 47, (byte) 81, - (byte) 103, (byte) 65, (byte) 69, (byte) 65, (byte) 65, (byte) 65, (byte) 65, - (byte) 65, (byte) 69, (byte) 97, (byte) 103, - }; - SBPMessage sbp = new SBPMessage(0x42, 0x402, payload); - MsgFwd msg = new MsgFwd(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_logging_MsgFwdTest.test1"); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)86,(byte)81,(byte)68,(byte)47,(byte)81,(byte)103,(byte)65,(byte)69,(byte)65,(byte)65,(byte)65,(byte)65,(byte)65,(byte)69,(byte)97,(byte)103, }; + SBPMessage sbp = new SBPMessage( 0x42, 0x402, payload ); + MsgFwd msg = new MsgFwd( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.fwd_payload[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[0] + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[0] + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -51,9 +50,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[1] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[1] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -61,9 +58,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[2] + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[2] + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -71,9 +66,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[3] + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[3] + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -81,9 +74,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[4] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[4] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -91,9 +82,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[5] + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[5] + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -101,9 +90,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[6] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[6] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -111,9 +98,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[7] + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[7] + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -121,9 +106,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[8] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[8] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -131,9 +114,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[9] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[9] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -141,9 +122,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[10] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[10] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -151,9 +130,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[11] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[11] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -161,9 +138,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[12] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[12] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -171,9 +146,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[13] + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[13] + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -181,9 +154,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[14] + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[14] + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -191,9 +162,7 @@ public void test1() throws Throwable { } value = msg.fwd_payload[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fwd_payload[15] + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.fwd_payload[15] + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -201,8 +170,7 @@ public void test1() throws Throwable { } value = msg.protocol; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.protocol + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.protocol + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -210,8 +178,7 @@ public void test1() throws Throwable { } value = msg.source; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.source + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.source + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; diff --git a/java/test/auto_check_sbp_logging_MsgLogTest.java b/java/test/auto_check_sbp_logging_MsgLogTest.java index 40588a118..f617de42c 100644 --- a/java/test/auto_check_sbp_logging_MsgLogTest.java +++ b/java/test/auto_check_sbp_logging_MsgLogTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/logging/test_MsgLog.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/logging/test_MsgLog.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.logging.MsgLog; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_logging_MsgLogTest { @@ -27,69 +32,23 @@ public class auto_check_sbp_logging_MsgLogTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_logging_MsgLogTest.test1"); - byte[] payload = - new byte[] { - (byte) 6, - (byte) 70, - (byte) 105, - (byte) 108, - (byte) 116, - (byte) 101, - (byte) 114, - (byte) 101, - (byte) 100, - (byte) 32, - (byte) 97, - (byte) 108, - (byte) 108, - (byte) 32, - (byte) 111, - (byte) 98, - (byte) 115, - (byte) 32, - (byte) 102, - (byte) 114, - (byte) 111, - (byte) 109, - (byte) 32, - (byte) 50, - (byte) 51, - (byte) 49, - (byte) 52, - (byte) 32, - (byte) 97, - (byte) 116, - (byte) 32, - (byte) 116, - (byte) 111, - (byte) 119, - (byte) 32, - (byte) 56, - (byte) 51, - (byte) 46, - (byte) 53, - (byte) 51, - (byte) 57, - (byte) 48, - (byte) 49, - (byte) 57, - }; - SBPMessage sbp = new SBPMessage(0x90a, 0x0401, payload); - MsgLog msg = new MsgLog(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_logging_MsgLogTest.test1"); + byte[] payload = new byte[] {(byte)6,(byte)70,(byte)105,(byte)108,(byte)116,(byte)101,(byte)114,(byte)101,(byte)100,(byte)32,(byte)97,(byte)108,(byte)108,(byte)32,(byte)111,(byte)98,(byte)115,(byte)32,(byte)102,(byte)114,(byte)111,(byte)109,(byte)32,(byte)50,(byte)51,(byte)49,(byte)52,(byte)32,(byte)97,(byte)116,(byte)32,(byte)116,(byte)111,(byte)119,(byte)32,(byte)56,(byte)51,(byte)46,(byte)53,(byte)51,(byte)57,(byte)48,(byte)49,(byte)57, }; + SBPMessage sbp = new SBPMessage( 0x90a, 0x0401, payload ); + MsgLog msg = new MsgLog( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.level + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.level + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; org.junit.Assert.assertEquals(value, expected); } - org.junit.Assert.assertEquals(msg.text, "Filtered all obs from 2314 at tow 83.539019"); + org.junit.Assert.assertEquals(msg.text, "Filtered all obs from 2314 at tow 83.539019" ); org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); } diff --git a/java/test/auto_check_sbp_logging_MsgPrintDepTest.java b/java/test/auto_check_sbp_logging_MsgPrintDepTest.java index a7ac8ed41..b860e2895 100644 --- a/java/test/auto_check_sbp_logging_MsgPrintDepTest.java +++ b/java/test/auto_check_sbp_logging_MsgPrintDepTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,16 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/logging/test_MsgPrintDep.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/logging/test_MsgPrintDep.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; +import org.junit.Test; + +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.logging.MsgPrintDep; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_logging_MsgPrintDepTest { @@ -26,191 +32,90 @@ public class auto_check_sbp_logging_MsgPrintDepTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_logging_MsgPrintDepTest.test1"); - byte[] payload = - new byte[] { - (byte) 73, (byte) 78, (byte) 70, (byte) 79, (byte) 58, (byte) 32, (byte) 97, - (byte) 99, (byte) 113, (byte) 58, (byte) 32, (byte) 80, (byte) 82, (byte) 78, - (byte) 32, (byte) 49, (byte) 53, (byte) 32, (byte) 102, (byte) 111, (byte) 117, - (byte) 110, (byte) 100, (byte) 32, (byte) 64, (byte) 32, (byte) 45, (byte) 50, - (byte) 52, (byte) 57, (byte) 55, (byte) 32, (byte) 72, (byte) 122, (byte) 44, - (byte) 32, (byte) 50, (byte) 48, (byte) 32, (byte) 83, (byte) 78, (byte) 82, - (byte) 10, - }; - SBPMessage sbp = new SBPMessage(0x2222, 0x10, payload); - MsgPrintDep msg = new MsgPrintDep(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_logging_MsgPrintDepTest.test1"); + byte[] payload = new byte[] {(byte)73,(byte)78,(byte)70,(byte)79,(byte)58,(byte)32,(byte)97,(byte)99,(byte)113,(byte)58,(byte)32,(byte)80,(byte)82,(byte)78,(byte)32,(byte)49,(byte)53,(byte)32,(byte)102,(byte)111,(byte)117,(byte)110,(byte)100,(byte)32,(byte)64,(byte)32,(byte)45,(byte)50,(byte)52,(byte)57,(byte)55,(byte)32,(byte)72,(byte)122,(byte)44,(byte)32,(byte)50,(byte)48,(byte)32,(byte)83,(byte)78,(byte)82,(byte)10, }; + SBPMessage sbp = new SBPMessage( 0x2222, 0x10, payload ); + MsgPrintDep msg = new MsgPrintDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; - org.junit.Assert.assertEquals(msg.text, "INFO: acq: PRN 15 found @ -2497 Hz, 20 SNR\n"); + org.junit.Assert.assertEquals(msg.text, "INFO: acq: PRN 15 found @ -2497 Hz, 20 SNR\n" ); org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); } @Test public void test2() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_logging_MsgPrintDepTest.test2"); - byte[] payload = - new byte[] { - (byte) 73, (byte) 78, (byte) 70, (byte) 79, (byte) 58, (byte) 32, (byte) 97, - (byte) 99, (byte) 113, (byte) 58, (byte) 32, (byte) 80, (byte) 82, (byte) 78, - (byte) 32, (byte) 51, (byte) 49, (byte) 32, (byte) 102, (byte) 111, (byte) 117, - (byte) 110, (byte) 100, (byte) 32, (byte) 64, (byte) 32, (byte) 52, (byte) 50, - (byte) 52, (byte) 53, (byte) 32, (byte) 72, (byte) 122, (byte) 44, (byte) 32, - (byte) 50, (byte) 49, (byte) 32, (byte) 83, (byte) 78, (byte) 82, (byte) 10, - }; - SBPMessage sbp = new SBPMessage(0x2222, 0x10, payload); - MsgPrintDep msg = new MsgPrintDep(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_logging_MsgPrintDepTest.test2"); + byte[] payload = new byte[] {(byte)73,(byte)78,(byte)70,(byte)79,(byte)58,(byte)32,(byte)97,(byte)99,(byte)113,(byte)58,(byte)32,(byte)80,(byte)82,(byte)78,(byte)32,(byte)51,(byte)49,(byte)32,(byte)102,(byte)111,(byte)117,(byte)110,(byte)100,(byte)32,(byte)64,(byte)32,(byte)52,(byte)50,(byte)52,(byte)53,(byte)32,(byte)72,(byte)122,(byte)44,(byte)32,(byte)50,(byte)49,(byte)32,(byte)83,(byte)78,(byte)82,(byte)10, }; + SBPMessage sbp = new SBPMessage( 0x2222, 0x10, payload ); + MsgPrintDep msg = new MsgPrintDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; - org.junit.Assert.assertEquals(msg.text, "INFO: acq: PRN 31 found @ 4245 Hz, 21 SNR\n"); + org.junit.Assert.assertEquals(msg.text, "INFO: acq: PRN 31 found @ 4245 Hz, 21 SNR\n" ); org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); } @Test public void test3() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_logging_MsgPrintDepTest.test3"); - byte[] payload = - new byte[] { - (byte) 73, - (byte) 78, - (byte) 70, - (byte) 79, - (byte) 58, - (byte) 32, - (byte) 68, - (byte) 105, - (byte) 115, - (byte) 97, - (byte) 98, - (byte) 108, - (byte) 105, - (byte) 110, - (byte) 103, - (byte) 32, - (byte) 99, - (byte) 104, - (byte) 97, - (byte) 110, - (byte) 110, - (byte) 101, - (byte) 108, - (byte) 32, - (byte) 48, - (byte) 32, - (byte) 40, - (byte) 80, - (byte) 82, - (byte) 78, - (byte) 32, - (byte) 49, - (byte) 49, - (byte) 41, - (byte) 10, - }; - SBPMessage sbp = new SBPMessage(0x2222, 0x10, payload); - MsgPrintDep msg = new MsgPrintDep(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_logging_MsgPrintDepTest.test3"); + byte[] payload = new byte[] {(byte)73,(byte)78,(byte)70,(byte)79,(byte)58,(byte)32,(byte)68,(byte)105,(byte)115,(byte)97,(byte)98,(byte)108,(byte)105,(byte)110,(byte)103,(byte)32,(byte)99,(byte)104,(byte)97,(byte)110,(byte)110,(byte)101,(byte)108,(byte)32,(byte)48,(byte)32,(byte)40,(byte)80,(byte)82,(byte)78,(byte)32,(byte)49,(byte)49,(byte)41,(byte)10, }; + SBPMessage sbp = new SBPMessage( 0x2222, 0x10, payload ); + MsgPrintDep msg = new MsgPrintDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; - org.junit.Assert.assertEquals(msg.text, "INFO: Disabling channel 0 (PRN 11)\n"); + org.junit.Assert.assertEquals(msg.text, "INFO: Disabling channel 0 (PRN 11)\n" ); org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); } @Test public void test4() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_logging_MsgPrintDepTest.test4"); - byte[] payload = - new byte[] { - (byte) 73, (byte) 78, (byte) 70, (byte) 79, (byte) 58, (byte) 32, (byte) 97, - (byte) 99, (byte) 113, (byte) 58, (byte) 32, (byte) 80, (byte) 82, (byte) 78, - (byte) 32, (byte) 50, (byte) 32, (byte) 102, (byte) 111, (byte) 117, (byte) 110, - (byte) 100, (byte) 32, (byte) 64, (byte) 32, (byte) 51, (byte) 57, (byte) 57, - (byte) 54, (byte) 32, (byte) 72, (byte) 122, (byte) 44, (byte) 32, (byte) 50, - (byte) 48, (byte) 32, (byte) 83, (byte) 78, (byte) 82, (byte) 10, - }; - SBPMessage sbp = new SBPMessage(0x2222, 0x10, payload); - MsgPrintDep msg = new MsgPrintDep(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_logging_MsgPrintDepTest.test4"); + byte[] payload = new byte[] {(byte)73,(byte)78,(byte)70,(byte)79,(byte)58,(byte)32,(byte)97,(byte)99,(byte)113,(byte)58,(byte)32,(byte)80,(byte)82,(byte)78,(byte)32,(byte)50,(byte)32,(byte)102,(byte)111,(byte)117,(byte)110,(byte)100,(byte)32,(byte)64,(byte)32,(byte)51,(byte)57,(byte)57,(byte)54,(byte)32,(byte)72,(byte)122,(byte)44,(byte)32,(byte)50,(byte)48,(byte)32,(byte)83,(byte)78,(byte)82,(byte)10, }; + SBPMessage sbp = new SBPMessage( 0x2222, 0x10, payload ); + MsgPrintDep msg = new MsgPrintDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; - org.junit.Assert.assertEquals(msg.text, "INFO: acq: PRN 2 found @ 3996 Hz, 20 SNR\n"); + org.junit.Assert.assertEquals(msg.text, "INFO: acq: PRN 2 found @ 3996 Hz, 20 SNR\n" ); org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); } @Test public void test5() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_logging_MsgPrintDepTest.test5"); - byte[] payload = - new byte[] { - (byte) 73, (byte) 78, (byte) 70, (byte) 79, (byte) 58, (byte) 32, (byte) 97, - (byte) 99, (byte) 113, (byte) 58, (byte) 32, (byte) 80, (byte) 82, (byte) 78, - (byte) 32, (byte) 52, (byte) 32, (byte) 102, (byte) 111, (byte) 117, (byte) 110, - (byte) 100, (byte) 32, (byte) 64, (byte) 32, (byte) 45, (byte) 55, (byte) 52, - (byte) 57, (byte) 50, (byte) 32, (byte) 72, (byte) 122, (byte) 44, (byte) 32, - (byte) 50, (byte) 48, (byte) 32, (byte) 83, (byte) 78, (byte) 82, (byte) 10, - }; - SBPMessage sbp = new SBPMessage(0x2222, 0x10, payload); - MsgPrintDep msg = new MsgPrintDep(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_logging_MsgPrintDepTest.test5"); + byte[] payload = new byte[] {(byte)73,(byte)78,(byte)70,(byte)79,(byte)58,(byte)32,(byte)97,(byte)99,(byte)113,(byte)58,(byte)32,(byte)80,(byte)82,(byte)78,(byte)32,(byte)52,(byte)32,(byte)102,(byte)111,(byte)117,(byte)110,(byte)100,(byte)32,(byte)64,(byte)32,(byte)45,(byte)55,(byte)52,(byte)57,(byte)50,(byte)32,(byte)72,(byte)122,(byte)44,(byte)32,(byte)50,(byte)48,(byte)32,(byte)83,(byte)78,(byte)82,(byte)10, }; + SBPMessage sbp = new SBPMessage( 0x2222, 0x10, payload ); + MsgPrintDep msg = new MsgPrintDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; - org.junit.Assert.assertEquals(msg.text, "INFO: acq: PRN 4 found @ -7492 Hz, 20 SNR\n"); + org.junit.Assert.assertEquals(msg.text, "INFO: acq: PRN 4 found @ -7492 Hz, 20 SNR\n" ); org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); } @Test public void test6() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_logging_MsgPrintDepTest.test6"); - byte[] payload = - new byte[] { - (byte) 73, - (byte) 78, - (byte) 70, - (byte) 79, - (byte) 58, - (byte) 32, - (byte) 68, - (byte) 105, - (byte) 115, - (byte) 97, - (byte) 98, - (byte) 108, - (byte) 105, - (byte) 110, - (byte) 103, - (byte) 32, - (byte) 99, - (byte) 104, - (byte) 97, - (byte) 110, - (byte) 110, - (byte) 101, - (byte) 108, - (byte) 32, - (byte) 49, - (byte) 32, - (byte) 40, - (byte) 80, - (byte) 82, - (byte) 78, - (byte) 32, - (byte) 49, - (byte) 53, - (byte) 41, - (byte) 10, - }; - SBPMessage sbp = new SBPMessage(0x2222, 0x10, payload); - MsgPrintDep msg = new MsgPrintDep(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_logging_MsgPrintDepTest.test6"); + byte[] payload = new byte[] {(byte)73,(byte)78,(byte)70,(byte)79,(byte)58,(byte)32,(byte)68,(byte)105,(byte)115,(byte)97,(byte)98,(byte)108,(byte)105,(byte)110,(byte)103,(byte)32,(byte)99,(byte)104,(byte)97,(byte)110,(byte)110,(byte)101,(byte)108,(byte)32,(byte)49,(byte)32,(byte)40,(byte)80,(byte)82,(byte)78,(byte)32,(byte)49,(byte)53,(byte)41,(byte)10, }; + SBPMessage sbp = new SBPMessage( 0x2222, 0x10, payload ); + MsgPrintDep msg = new MsgPrintDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; - org.junit.Assert.assertEquals(msg.text, "INFO: Disabling channel 1 (PRN 15)\n"); + org.junit.Assert.assertEquals(msg.text, "INFO: Disabling channel 1 (PRN 15)\n" ); org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); } diff --git a/java/test/auto_check_sbp_mag_MsgMagRawTest.java b/java/test/auto_check_sbp_mag_MsgMagRawTest.java index 1fa747878..42e46195c 100644 --- a/java/test/auto_check_sbp_mag_MsgMagRawTest.java +++ b/java/test/auto_check_sbp_mag_MsgMagRawTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/mag/test_MsgMagRaw.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/mag/test_MsgMagRaw.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.mag.MsgMagRaw; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_mag_MsgMagRawTest { @@ -27,30 +32,17 @@ public class auto_check_sbp_mag_MsgMagRawTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_mag_MsgMagRawTest.test1"); - byte[] payload = - new byte[] { - (byte) 173, - (byte) 227, - (byte) 158, - (byte) 198, - (byte) 206, - (byte) 98, - (byte) 3, - (byte) 230, - (byte) 2, - (byte) 110, - (byte) 229, - }; - SBPMessage sbp = new SBPMessage(0x04c3, 0x902, payload); - MsgMagRaw msg = new MsgMagRaw(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_mag_MsgMagRawTest.test1"); + byte[] payload = new byte[] {(byte)173,(byte)227,(byte)158,(byte)198,(byte)206,(byte)98,(byte)3,(byte)230,(byte)2,(byte)110,(byte)229, }; + SBPMessage sbp = new SBPMessage( 0x04c3, 0x902, payload ); + MsgMagRaw msg = new MsgMagRaw( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.mag_x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.mag_x + "' != '" + 866 + "'", value.equals(BigInteger.valueOf(866L))); + org.junit.Assert.assertTrue("'" + msg.mag_x + "' != '" + 866 + "'", value.equals(BigInteger.valueOf( 866L ) ) ); } else { value = value.longValue(); expected = 866L; @@ -58,8 +50,7 @@ public void test1() throws Throwable { } value = msg.mag_y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.mag_y + "' != '" + 742 + "'", value.equals(BigInteger.valueOf(742L))); + org.junit.Assert.assertTrue("'" + msg.mag_y + "' != '" + 742 + "'", value.equals(BigInteger.valueOf( 742L ) ) ); } else { value = value.longValue(); expected = 742L; @@ -67,9 +58,7 @@ public void test1() throws Throwable { } value = msg.mag_z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.mag_z + "' != '" + -6802 + "'", - value.equals(BigInteger.valueOf(-6802L))); + org.junit.Assert.assertTrue("'" + msg.mag_z + "' != '" + -6802 + "'", value.equals(BigInteger.valueOf( -6802L ) ) ); } else { value = value.longValue(); expected = -6802L; @@ -77,9 +66,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 3332301741L + "'", - value.equals(new BigInteger("3332301741"))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 3332301741L + "'", value.equals( new BigInteger( "3332301741" ) ) ); } else { value = value.longValue(); expected = 3332301741L; @@ -87,8 +74,7 @@ public void test1() throws Throwable { } value = msg.tow_f; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow_f + "' != '" + 206 + "'", value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.tow_f + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; diff --git a/java/test/auto_check_sbp_navigation_MsgAgeCorrectionsTest.java b/java/test/auto_check_sbp_navigation_MsgAgeCorrectionsTest.java index 9e1a6d757..afc314d37 100644 --- a/java/test/auto_check_sbp_navigation_MsgAgeCorrectionsTest.java +++ b/java/test/auto_check_sbp_navigation_MsgAgeCorrectionsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgAgeCorrections.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgAgeCorrections.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgAgeCorrections; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgAgeCorrectionsTest { @@ -30,19 +34,15 @@ public class auto_check_sbp_navigation_MsgAgeCorrectionsTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgAgeCorrectionsTest.test1"); - byte[] payload = - new byte[] { - (byte) 100, (byte) 0, (byte) 0, (byte) 0, (byte) 30, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x42, 0x210, payload); - MsgAgeCorrections msg = new MsgAgeCorrections(sbp); + byte[] payload = new byte[] {(byte)100,(byte)0,(byte)0,(byte)0,(byte)30,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x42, 0x210, payload ); + MsgAgeCorrections msg = new MsgAgeCorrections( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.age; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.age + "' != '" + 30 + "'", value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.age + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -50,8 +50,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 100 + "'", value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; diff --git a/java/test/auto_check_sbp_navigation_MsgBaselineECEFDepATest.java b/java/test/auto_check_sbp_navigation_MsgBaselineECEFDepATest.java index cc8e34757..bc9a07ed9 100644 --- a/java/test/auto_check_sbp_navigation_MsgBaselineECEFDepATest.java +++ b/java/test/auto_check_sbp_navigation_MsgBaselineECEFDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgBaselineECEFDepA.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgBaselineECEFDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgBaselineECEFDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgBaselineECEFDepATest { @@ -30,38 +34,15 @@ public class auto_check_sbp_navigation_MsgBaselineECEFDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 20, - (byte) 46, - (byte) 39, - (byte) 0, - (byte) 21, - (byte) 48, - (byte) 255, - (byte) 255, - (byte) 52, - (byte) 117, - (byte) 255, - (byte) 255, - (byte) 216, - (byte) 211, - (byte) 254, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x202, payload); - MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA(sbp); + byte[] payload = new byte[] {(byte)20,(byte)46,(byte)39,(byte)0,(byte)21,(byte)48,(byte)255,(byte)255,(byte)52,(byte)117,(byte)255,(byte)255,(byte)216,(byte)211,(byte)254,(byte)255,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x202, payload ); + MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -69,8 +50,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -78,8 +58,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -87,9 +66,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567700 + "'", - value.equals(BigInteger.valueOf(2567700L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567700 + "'", value.equals(BigInteger.valueOf( 2567700L ) ) ); } else { value = value.longValue(); expected = 2567700L; @@ -97,9 +74,7 @@ public void test1() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -53227 + "'", - value.equals(BigInteger.valueOf(-53227L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -53227 + "'", value.equals(BigInteger.valueOf( -53227L ) ) ); } else { value = value.longValue(); expected = -53227L; @@ -107,9 +82,7 @@ public void test1() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + -35532 + "'", - value.equals(BigInteger.valueOf(-35532L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + -35532 + "'", value.equals(BigInteger.valueOf( -35532L ) ) ); } else { value = value.longValue(); expected = -35532L; @@ -117,9 +90,7 @@ public void test1() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + -76840 + "'", - value.equals(BigInteger.valueOf(-76840L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + -76840 + "'", value.equals(BigInteger.valueOf( -76840L ) ) ); } else { value = value.longValue(); expected = -76840L; @@ -133,38 +104,15 @@ public void test1() throws Throwable { public void test2() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFDepATest.test2"); - byte[] payload = - new byte[] { - (byte) 120, - (byte) 46, - (byte) 39, - (byte) 0, - (byte) 58, - (byte) 49, - (byte) 255, - (byte) 255, - (byte) 49, - (byte) 116, - (byte) 255, - (byte) 255, - (byte) 134, - (byte) 211, - (byte) 254, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x202, payload); - MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA(sbp); + byte[] payload = new byte[] {(byte)120,(byte)46,(byte)39,(byte)0,(byte)58,(byte)49,(byte)255,(byte)255,(byte)49,(byte)116,(byte)255,(byte)255,(byte)134,(byte)211,(byte)254,(byte)255,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x202, payload ); + MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -172,8 +120,7 @@ public void test2() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -181,8 +128,7 @@ public void test2() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -190,9 +136,7 @@ public void test2() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567800 + "'", - value.equals(BigInteger.valueOf(2567800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567800 + "'", value.equals(BigInteger.valueOf( 2567800L ) ) ); } else { value = value.longValue(); expected = 2567800L; @@ -200,9 +144,7 @@ public void test2() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -52934 + "'", - value.equals(BigInteger.valueOf(-52934L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -52934 + "'", value.equals(BigInteger.valueOf( -52934L ) ) ); } else { value = value.longValue(); expected = -52934L; @@ -210,9 +152,7 @@ public void test2() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + -35791 + "'", - value.equals(BigInteger.valueOf(-35791L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + -35791 + "'", value.equals(BigInteger.valueOf( -35791L ) ) ); } else { value = value.longValue(); expected = -35791L; @@ -220,9 +160,7 @@ public void test2() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + -76922 + "'", - value.equals(BigInteger.valueOf(-76922L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + -76922 + "'", value.equals(BigInteger.valueOf( -76922L ) ) ); } else { value = value.longValue(); expected = -76922L; @@ -236,38 +174,15 @@ public void test2() throws Throwable { public void test3() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFDepATest.test3"); - byte[] payload = - new byte[] { - (byte) 220, - (byte) 46, - (byte) 39, - (byte) 0, - (byte) 97, - (byte) 50, - (byte) 255, - (byte) 255, - (byte) 47, - (byte) 115, - (byte) 255, - (byte) 255, - (byte) 52, - (byte) 211, - (byte) 254, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x202, payload); - MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA(sbp); + byte[] payload = new byte[] {(byte)220,(byte)46,(byte)39,(byte)0,(byte)97,(byte)50,(byte)255,(byte)255,(byte)47,(byte)115,(byte)255,(byte)255,(byte)52,(byte)211,(byte)254,(byte)255,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x202, payload ); + MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -275,8 +190,7 @@ public void test3() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -284,8 +198,7 @@ public void test3() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -293,9 +206,7 @@ public void test3() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567900 + "'", - value.equals(BigInteger.valueOf(2567900L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567900 + "'", value.equals(BigInteger.valueOf( 2567900L ) ) ); } else { value = value.longValue(); expected = 2567900L; @@ -303,9 +214,7 @@ public void test3() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -52639 + "'", - value.equals(BigInteger.valueOf(-52639L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -52639 + "'", value.equals(BigInteger.valueOf( -52639L ) ) ); } else { value = value.longValue(); expected = -52639L; @@ -313,9 +222,7 @@ public void test3() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + -36049 + "'", - value.equals(BigInteger.valueOf(-36049L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + -36049 + "'", value.equals(BigInteger.valueOf( -36049L ) ) ); } else { value = value.longValue(); expected = -36049L; @@ -323,9 +230,7 @@ public void test3() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + -77004 + "'", - value.equals(BigInteger.valueOf(-77004L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + -77004 + "'", value.equals(BigInteger.valueOf( -77004L ) ) ); } else { value = value.longValue(); expected = -77004L; @@ -339,38 +244,15 @@ public void test3() throws Throwable { public void test4() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFDepATest.test4"); - byte[] payload = - new byte[] { - (byte) 64, - (byte) 47, - (byte) 39, - (byte) 0, - (byte) 136, - (byte) 51, - (byte) 255, - (byte) 255, - (byte) 45, - (byte) 114, - (byte) 255, - (byte) 255, - (byte) 228, - (byte) 210, - (byte) 254, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x202, payload); - MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA(sbp); + byte[] payload = new byte[] {(byte)64,(byte)47,(byte)39,(byte)0,(byte)136,(byte)51,(byte)255,(byte)255,(byte)45,(byte)114,(byte)255,(byte)255,(byte)228,(byte)210,(byte)254,(byte)255,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x202, payload ); + MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -378,8 +260,7 @@ public void test4() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -387,8 +268,7 @@ public void test4() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -396,9 +276,7 @@ public void test4() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2568000 + "'", - value.equals(BigInteger.valueOf(2568000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2568000 + "'", value.equals(BigInteger.valueOf( 2568000L ) ) ); } else { value = value.longValue(); expected = 2568000L; @@ -406,9 +284,7 @@ public void test4() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -52344 + "'", - value.equals(BigInteger.valueOf(-52344L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -52344 + "'", value.equals(BigInteger.valueOf( -52344L ) ) ); } else { value = value.longValue(); expected = -52344L; @@ -416,9 +292,7 @@ public void test4() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + -36307 + "'", - value.equals(BigInteger.valueOf(-36307L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + -36307 + "'", value.equals(BigInteger.valueOf( -36307L ) ) ); } else { value = value.longValue(); expected = -36307L; @@ -426,9 +300,7 @@ public void test4() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + -77084 + "'", - value.equals(BigInteger.valueOf(-77084L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + -77084 + "'", value.equals(BigInteger.valueOf( -77084L ) ) ); } else { value = value.longValue(); expected = -77084L; @@ -442,38 +314,15 @@ public void test4() throws Throwable { public void test5() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFDepATest.test5"); - byte[] payload = - new byte[] { - (byte) 164, - (byte) 47, - (byte) 39, - (byte) 0, - (byte) 176, - (byte) 52, - (byte) 255, - (byte) 255, - (byte) 44, - (byte) 113, - (byte) 255, - (byte) 255, - (byte) 149, - (byte) 210, - (byte) 254, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x202, payload); - MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA(sbp); + byte[] payload = new byte[] {(byte)164,(byte)47,(byte)39,(byte)0,(byte)176,(byte)52,(byte)255,(byte)255,(byte)44,(byte)113,(byte)255,(byte)255,(byte)149,(byte)210,(byte)254,(byte)255,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x202, payload ); + MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -481,8 +330,7 @@ public void test5() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -490,8 +338,7 @@ public void test5() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -499,9 +346,7 @@ public void test5() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2568100 + "'", - value.equals(BigInteger.valueOf(2568100L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2568100 + "'", value.equals(BigInteger.valueOf( 2568100L ) ) ); } else { value = value.longValue(); expected = 2568100L; @@ -509,9 +354,7 @@ public void test5() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -52048 + "'", - value.equals(BigInteger.valueOf(-52048L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -52048 + "'", value.equals(BigInteger.valueOf( -52048L ) ) ); } else { value = value.longValue(); expected = -52048L; @@ -519,9 +362,7 @@ public void test5() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + -36564 + "'", - value.equals(BigInteger.valueOf(-36564L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + -36564 + "'", value.equals(BigInteger.valueOf( -36564L ) ) ); } else { value = value.longValue(); expected = -36564L; @@ -529,9 +370,7 @@ public void test5() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + -77163 + "'", - value.equals(BigInteger.valueOf(-77163L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + -77163 + "'", value.equals(BigInteger.valueOf( -77163L ) ) ); } else { value = value.longValue(); expected = -77163L; @@ -545,38 +384,15 @@ public void test5() throws Throwable { public void test6() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFDepATest.test6"); - byte[] payload = - new byte[] { - (byte) 156, - (byte) 21, - (byte) 69, - (byte) 24, - (byte) 169, - (byte) 231, - (byte) 255, - (byte) 255, - (byte) 102, - (byte) 208, - (byte) 255, - (byte) 255, - (byte) 251, - (byte) 28, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 6, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x202, payload); - MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA(sbp); + byte[] payload = new byte[] {(byte)156,(byte)21,(byte)69,(byte)24,(byte)169,(byte)231,(byte)255,(byte)255,(byte)102,(byte)208,(byte)255,(byte)255,(byte)251,(byte)28,(byte)0,(byte)0,(byte)0,(byte)0,(byte)6,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x202, payload ); + MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -584,8 +400,7 @@ public void test6() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -593,8 +408,7 @@ public void test6() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -602,9 +416,7 @@ public void test6() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407180700 + "'", - value.equals(BigInteger.valueOf(407180700L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407180700 + "'", value.equals(BigInteger.valueOf( 407180700L ) ) ); } else { value = value.longValue(); expected = 407180700L; @@ -612,8 +424,7 @@ public void test6() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -6231 + "'", value.equals(BigInteger.valueOf(-6231L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -6231 + "'", value.equals(BigInteger.valueOf( -6231L ) ) ); } else { value = value.longValue(); expected = -6231L; @@ -621,9 +432,7 @@ public void test6() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + -12186 + "'", - value.equals(BigInteger.valueOf(-12186L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + -12186 + "'", value.equals(BigInteger.valueOf( -12186L ) ) ); } else { value = value.longValue(); expected = -12186L; @@ -631,8 +440,7 @@ public void test6() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + 7419 + "'", value.equals(BigInteger.valueOf(7419L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + 7419 + "'", value.equals(BigInteger.valueOf( 7419L ) ) ); } else { value = value.longValue(); expected = 7419L; @@ -646,38 +454,15 @@ public void test6() throws Throwable { public void test7() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFDepATest.test7"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 22, - (byte) 69, - (byte) 24, - (byte) 169, - (byte) 231, - (byte) 255, - (byte) 255, - (byte) 103, - (byte) 208, - (byte) 255, - (byte) 255, - (byte) 252, - (byte) 28, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 6, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x202, payload); - MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA(sbp); + byte[] payload = new byte[] {(byte)0,(byte)22,(byte)69,(byte)24,(byte)169,(byte)231,(byte)255,(byte)255,(byte)103,(byte)208,(byte)255,(byte)255,(byte)252,(byte)28,(byte)0,(byte)0,(byte)0,(byte)0,(byte)6,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x202, payload ); + MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -685,8 +470,7 @@ public void test7() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -694,8 +478,7 @@ public void test7() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -703,9 +486,7 @@ public void test7() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407180800 + "'", - value.equals(BigInteger.valueOf(407180800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407180800 + "'", value.equals(BigInteger.valueOf( 407180800L ) ) ); } else { value = value.longValue(); expected = 407180800L; @@ -713,8 +494,7 @@ public void test7() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -6231 + "'", value.equals(BigInteger.valueOf(-6231L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -6231 + "'", value.equals(BigInteger.valueOf( -6231L ) ) ); } else { value = value.longValue(); expected = -6231L; @@ -722,9 +502,7 @@ public void test7() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + -12185 + "'", - value.equals(BigInteger.valueOf(-12185L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + -12185 + "'", value.equals(BigInteger.valueOf( -12185L ) ) ); } else { value = value.longValue(); expected = -12185L; @@ -732,8 +510,7 @@ public void test7() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + 7420 + "'", value.equals(BigInteger.valueOf(7420L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + 7420 + "'", value.equals(BigInteger.valueOf( 7420L ) ) ); } else { value = value.longValue(); expected = 7420L; @@ -747,38 +524,15 @@ public void test7() throws Throwable { public void test8() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFDepATest.test8"); - byte[] payload = - new byte[] { - (byte) 100, - (byte) 22, - (byte) 69, - (byte) 24, - (byte) 30, - (byte) 224, - (byte) 255, - (byte) 255, - (byte) 192, - (byte) 183, - (byte) 255, - (byte) 255, - (byte) 239, - (byte) 53, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 6, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x202, payload); - MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA(sbp); + byte[] payload = new byte[] {(byte)100,(byte)22,(byte)69,(byte)24,(byte)30,(byte)224,(byte)255,(byte)255,(byte)192,(byte)183,(byte)255,(byte)255,(byte)239,(byte)53,(byte)0,(byte)0,(byte)0,(byte)0,(byte)6,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x202, payload ); + MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -786,8 +540,7 @@ public void test8() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -795,8 +548,7 @@ public void test8() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -804,9 +556,7 @@ public void test8() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407180900 + "'", - value.equals(BigInteger.valueOf(407180900L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407180900 + "'", value.equals(BigInteger.valueOf( 407180900L ) ) ); } else { value = value.longValue(); expected = 407180900L; @@ -814,8 +564,7 @@ public void test8() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -8162 + "'", value.equals(BigInteger.valueOf(-8162L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -8162 + "'", value.equals(BigInteger.valueOf( -8162L ) ) ); } else { value = value.longValue(); expected = -8162L; @@ -823,9 +572,7 @@ public void test8() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + -18496 + "'", - value.equals(BigInteger.valueOf(-18496L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + -18496 + "'", value.equals(BigInteger.valueOf( -18496L ) ) ); } else { value = value.longValue(); expected = -18496L; @@ -833,8 +580,7 @@ public void test8() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + 13807 + "'", value.equals(BigInteger.valueOf(13807L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + 13807 + "'", value.equals(BigInteger.valueOf( 13807L ) ) ); } else { value = value.longValue(); expected = 13807L; @@ -848,38 +594,15 @@ public void test8() throws Throwable { public void test9() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFDepATest.test9"); - byte[] payload = - new byte[] { - (byte) 200, - (byte) 22, - (byte) 69, - (byte) 24, - (byte) 28, - (byte) 224, - (byte) 255, - (byte) 255, - (byte) 191, - (byte) 183, - (byte) 255, - (byte) 255, - (byte) 242, - (byte) 53, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 6, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x202, payload); - MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA(sbp); + byte[] payload = new byte[] {(byte)200,(byte)22,(byte)69,(byte)24,(byte)28,(byte)224,(byte)255,(byte)255,(byte)191,(byte)183,(byte)255,(byte)255,(byte)242,(byte)53,(byte)0,(byte)0,(byte)0,(byte)0,(byte)6,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x202, payload ); + MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -887,8 +610,7 @@ public void test9() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -896,8 +618,7 @@ public void test9() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -905,9 +626,7 @@ public void test9() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407181000 + "'", - value.equals(BigInteger.valueOf(407181000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407181000 + "'", value.equals(BigInteger.valueOf( 407181000L ) ) ); } else { value = value.longValue(); expected = 407181000L; @@ -915,8 +634,7 @@ public void test9() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -8164 + "'", value.equals(BigInteger.valueOf(-8164L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -8164 + "'", value.equals(BigInteger.valueOf( -8164L ) ) ); } else { value = value.longValue(); expected = -8164L; @@ -924,9 +642,7 @@ public void test9() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + -18497 + "'", - value.equals(BigInteger.valueOf(-18497L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + -18497 + "'", value.equals(BigInteger.valueOf( -18497L ) ) ); } else { value = value.longValue(); expected = -18497L; @@ -934,8 +650,7 @@ public void test9() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + 13810 + "'", value.equals(BigInteger.valueOf(13810L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + 13810 + "'", value.equals(BigInteger.valueOf( 13810L ) ) ); } else { value = value.longValue(); expected = 13810L; @@ -949,38 +664,15 @@ public void test9() throws Throwable { public void test10() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFDepATest.test10"); - byte[] payload = - new byte[] { - (byte) 44, - (byte) 23, - (byte) 69, - (byte) 24, - (byte) 24, - (byte) 227, - (byte) 255, - (byte) 255, - (byte) 25, - (byte) 195, - (byte) 255, - (byte) 255, - (byte) 153, - (byte) 59, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 6, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x202, payload); - MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA(sbp); + byte[] payload = new byte[] {(byte)44,(byte)23,(byte)69,(byte)24,(byte)24,(byte)227,(byte)255,(byte)255,(byte)25,(byte)195,(byte)255,(byte)255,(byte)153,(byte)59,(byte)0,(byte)0,(byte)0,(byte)0,(byte)6,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x202, payload ); + MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -988,8 +680,7 @@ public void test10() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -997,8 +688,7 @@ public void test10() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1006,9 +696,7 @@ public void test10() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407181100 + "'", - value.equals(BigInteger.valueOf(407181100L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407181100 + "'", value.equals(BigInteger.valueOf( 407181100L ) ) ); } else { value = value.longValue(); expected = 407181100L; @@ -1016,8 +704,7 @@ public void test10() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -7400 + "'", value.equals(BigInteger.valueOf(-7400L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -7400 + "'", value.equals(BigInteger.valueOf( -7400L ) ) ); } else { value = value.longValue(); expected = -7400L; @@ -1025,9 +712,7 @@ public void test10() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + -15591 + "'", - value.equals(BigInteger.valueOf(-15591L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + -15591 + "'", value.equals(BigInteger.valueOf( -15591L ) ) ); } else { value = value.longValue(); expected = -15591L; @@ -1035,8 +720,7 @@ public void test10() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + 15257 + "'", value.equals(BigInteger.valueOf(15257L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + 15257 + "'", value.equals(BigInteger.valueOf( 15257L ) ) ); } else { value = value.longValue(); expected = 15257L; @@ -1050,38 +734,15 @@ public void test10() throws Throwable { public void test11() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFDepATest.test11"); - byte[] payload = - new byte[] { - (byte) 144, - (byte) 23, - (byte) 69, - (byte) 24, - (byte) 23, - (byte) 227, - (byte) 255, - (byte) 255, - (byte) 25, - (byte) 195, - (byte) 255, - (byte) 255, - (byte) 153, - (byte) 59, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 6, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x202, payload); - MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA(sbp); + byte[] payload = new byte[] {(byte)144,(byte)23,(byte)69,(byte)24,(byte)23,(byte)227,(byte)255,(byte)255,(byte)25,(byte)195,(byte)255,(byte)255,(byte)153,(byte)59,(byte)0,(byte)0,(byte)0,(byte)0,(byte)6,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x202, payload ); + MsgBaselineECEFDepA msg = new MsgBaselineECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1089,8 +750,7 @@ public void test11() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1098,8 +758,7 @@ public void test11() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1107,9 +766,7 @@ public void test11() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407181200 + "'", - value.equals(BigInteger.valueOf(407181200L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407181200 + "'", value.equals(BigInteger.valueOf( 407181200L ) ) ); } else { value = value.longValue(); expected = 407181200L; @@ -1117,8 +774,7 @@ public void test11() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -7401 + "'", value.equals(BigInteger.valueOf(-7401L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -7401 + "'", value.equals(BigInteger.valueOf( -7401L ) ) ); } else { value = value.longValue(); expected = -7401L; @@ -1126,9 +782,7 @@ public void test11() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + -15591 + "'", - value.equals(BigInteger.valueOf(-15591L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + -15591 + "'", value.equals(BigInteger.valueOf( -15591L ) ) ); } else { value = value.longValue(); expected = -15591L; @@ -1136,8 +790,7 @@ public void test11() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + 15257 + "'", value.equals(BigInteger.valueOf(15257L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + 15257 + "'", value.equals(BigInteger.valueOf( 15257L ) ) ); } else { value = value.longValue(); expected = 15257L; diff --git a/java/test/auto_check_sbp_navigation_MsgBaselineECEFTest.java b/java/test/auto_check_sbp_navigation_MsgBaselineECEFTest.java index ed2be6e18..244ee9cc9 100644 --- a/java/test/auto_check_sbp_navigation_MsgBaselineECEFTest.java +++ b/java/test/auto_check_sbp_navigation_MsgBaselineECEFTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgBaselineECEF.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgBaselineECEF.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgBaselineECEF; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgBaselineECEFTest { @@ -30,21 +34,15 @@ public class auto_check_sbp_navigation_MsgBaselineECEFTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFTest.test1"); - byte[] payload = - new byte[] { - (byte) 40, (byte) 244, (byte) 122, (byte) 19, (byte) 150, (byte) 98, (byte) 238, - (byte) 255, (byte) 190, (byte) 64, (byte) 20, (byte) 0, (byte) 246, (byte) 163, - (byte) 9, (byte) 0, (byte) 0, (byte) 0, (byte) 14, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20b, payload); - MsgBaselineECEF msg = new MsgBaselineECEF(sbp); + byte[] payload = new byte[] {(byte)40,(byte)244,(byte)122,(byte)19,(byte)150,(byte)98,(byte)238,(byte)255,(byte)190,(byte)64,(byte)20,(byte)0,(byte)246,(byte)163,(byte)9,(byte)0,(byte)0,(byte)0,(byte)14,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20b, payload ); + MsgBaselineECEF msg = new MsgBaselineECEF( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -52,8 +50,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -61,8 +58,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 14 + "'", value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -70,9 +66,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326825000 + "'", - value.equals(BigInteger.valueOf(326825000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326825000 + "'", value.equals(BigInteger.valueOf( 326825000L ) ) ); } else { value = value.longValue(); expected = 326825000L; @@ -80,9 +74,7 @@ public void test1() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -1154410 + "'", - value.equals(BigInteger.valueOf(-1154410L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -1154410 + "'", value.equals(BigInteger.valueOf( -1154410L ) ) ); } else { value = value.longValue(); expected = -1154410L; @@ -90,9 +82,7 @@ public void test1() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + 1327294 + "'", - value.equals(BigInteger.valueOf(1327294L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + 1327294 + "'", value.equals(BigInteger.valueOf( 1327294L ) ) ); } else { value = value.longValue(); expected = 1327294L; @@ -100,9 +90,7 @@ public void test1() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + 631798 + "'", - value.equals(BigInteger.valueOf(631798L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + 631798 + "'", value.equals(BigInteger.valueOf( 631798L ) ) ); } else { value = value.longValue(); expected = 631798L; @@ -116,21 +104,15 @@ public void test1() throws Throwable { public void test2() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFTest.test2"); - byte[] payload = - new byte[] { - (byte) 16, (byte) 248, (byte) 122, (byte) 19, (byte) 72, (byte) 99, (byte) 238, - (byte) 255, (byte) 191, (byte) 65, (byte) 20, (byte) 0, (byte) 138, (byte) 162, - (byte) 9, (byte) 0, (byte) 0, (byte) 0, (byte) 15, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20b, payload); - MsgBaselineECEF msg = new MsgBaselineECEF(sbp); + byte[] payload = new byte[] {(byte)16,(byte)248,(byte)122,(byte)19,(byte)72,(byte)99,(byte)238,(byte)255,(byte)191,(byte)65,(byte)20,(byte)0,(byte)138,(byte)162,(byte)9,(byte)0,(byte)0,(byte)0,(byte)15,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20b, payload ); + MsgBaselineECEF msg = new MsgBaselineECEF( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -138,8 +120,7 @@ public void test2() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -147,8 +128,7 @@ public void test2() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -156,9 +136,7 @@ public void test2() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326826000 + "'", - value.equals(BigInteger.valueOf(326826000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326826000 + "'", value.equals(BigInteger.valueOf( 326826000L ) ) ); } else { value = value.longValue(); expected = 326826000L; @@ -166,9 +144,7 @@ public void test2() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -1154232 + "'", - value.equals(BigInteger.valueOf(-1154232L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -1154232 + "'", value.equals(BigInteger.valueOf( -1154232L ) ) ); } else { value = value.longValue(); expected = -1154232L; @@ -176,9 +152,7 @@ public void test2() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + 1327551 + "'", - value.equals(BigInteger.valueOf(1327551L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + 1327551 + "'", value.equals(BigInteger.valueOf( 1327551L ) ) ); } else { value = value.longValue(); expected = 1327551L; @@ -186,9 +160,7 @@ public void test2() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + 631434 + "'", - value.equals(BigInteger.valueOf(631434L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + 631434 + "'", value.equals(BigInteger.valueOf( 631434L ) ) ); } else { value = value.longValue(); expected = 631434L; @@ -202,21 +174,15 @@ public void test2() throws Throwable { public void test3() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFTest.test3"); - byte[] payload = - new byte[] { - (byte) 248, (byte) 251, (byte) 122, (byte) 19, (byte) 41, (byte) 99, (byte) 238, - (byte) 255, (byte) 181, (byte) 65, (byte) 20, (byte) 0, (byte) 148, (byte) 161, - (byte) 9, (byte) 0, (byte) 0, (byte) 0, (byte) 15, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20b, payload); - MsgBaselineECEF msg = new MsgBaselineECEF(sbp); + byte[] payload = new byte[] {(byte)248,(byte)251,(byte)122,(byte)19,(byte)41,(byte)99,(byte)238,(byte)255,(byte)181,(byte)65,(byte)20,(byte)0,(byte)148,(byte)161,(byte)9,(byte)0,(byte)0,(byte)0,(byte)15,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20b, payload ); + MsgBaselineECEF msg = new MsgBaselineECEF( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -224,8 +190,7 @@ public void test3() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -233,8 +198,7 @@ public void test3() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -242,9 +206,7 @@ public void test3() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326827000 + "'", - value.equals(BigInteger.valueOf(326827000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326827000 + "'", value.equals(BigInteger.valueOf( 326827000L ) ) ); } else { value = value.longValue(); expected = 326827000L; @@ -252,9 +214,7 @@ public void test3() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -1154263 + "'", - value.equals(BigInteger.valueOf(-1154263L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -1154263 + "'", value.equals(BigInteger.valueOf( -1154263L ) ) ); } else { value = value.longValue(); expected = -1154263L; @@ -262,9 +222,7 @@ public void test3() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + 1327541 + "'", - value.equals(BigInteger.valueOf(1327541L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + 1327541 + "'", value.equals(BigInteger.valueOf( 1327541L ) ) ); } else { value = value.longValue(); expected = 1327541L; @@ -272,9 +230,7 @@ public void test3() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + 631188 + "'", - value.equals(BigInteger.valueOf(631188L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + 631188 + "'", value.equals(BigInteger.valueOf( 631188L ) ) ); } else { value = value.longValue(); expected = 631188L; @@ -288,38 +244,15 @@ public void test3() throws Throwable { public void test4() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFTest.test4"); - byte[] payload = - new byte[] { - (byte) 224, - (byte) 255, - (byte) 122, - (byte) 19, - (byte) 188, - (byte) 97, - (byte) 238, - (byte) 255, - (byte) 81, - (byte) 64, - (byte) 20, - (byte) 0, - (byte) 65, - (byte) 160, - (byte) 9, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 15, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20b, payload); - MsgBaselineECEF msg = new MsgBaselineECEF(sbp); + byte[] payload = new byte[] {(byte)224,(byte)255,(byte)122,(byte)19,(byte)188,(byte)97,(byte)238,(byte)255,(byte)81,(byte)64,(byte)20,(byte)0,(byte)65,(byte)160,(byte)9,(byte)0,(byte)0,(byte)0,(byte)15,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20b, payload ); + MsgBaselineECEF msg = new MsgBaselineECEF( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -327,8 +260,7 @@ public void test4() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -336,8 +268,7 @@ public void test4() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -345,9 +276,7 @@ public void test4() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326828000 + "'", - value.equals(BigInteger.valueOf(326828000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326828000 + "'", value.equals(BigInteger.valueOf( 326828000L ) ) ); } else { value = value.longValue(); expected = 326828000L; @@ -355,9 +284,7 @@ public void test4() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -1154628 + "'", - value.equals(BigInteger.valueOf(-1154628L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -1154628 + "'", value.equals(BigInteger.valueOf( -1154628L ) ) ); } else { value = value.longValue(); expected = -1154628L; @@ -365,9 +292,7 @@ public void test4() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + 1327185 + "'", - value.equals(BigInteger.valueOf(1327185L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + 1327185 + "'", value.equals(BigInteger.valueOf( 1327185L ) ) ); } else { value = value.longValue(); expected = 1327185L; @@ -375,9 +300,7 @@ public void test4() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + 630849 + "'", - value.equals(BigInteger.valueOf(630849L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + 630849 + "'", value.equals(BigInteger.valueOf( 630849L ) ) ); } else { value = value.longValue(); expected = 630849L; @@ -391,21 +314,15 @@ public void test4() throws Throwable { public void test5() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineECEFTest.test5"); - byte[] payload = - new byte[] { - (byte) 200, (byte) 3, (byte) 123, (byte) 19, (byte) 189, (byte) 96, (byte) 238, - (byte) 255, (byte) 93, (byte) 63, (byte) 20, (byte) 0, (byte) 98, (byte) 159, - (byte) 9, (byte) 0, (byte) 0, (byte) 0, (byte) 15, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20b, payload); - MsgBaselineECEF msg = new MsgBaselineECEF(sbp); + byte[] payload = new byte[] {(byte)200,(byte)3,(byte)123,(byte)19,(byte)189,(byte)96,(byte)238,(byte)255,(byte)93,(byte)63,(byte)20,(byte)0,(byte)98,(byte)159,(byte)9,(byte)0,(byte)0,(byte)0,(byte)15,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20b, payload ); + MsgBaselineECEF msg = new MsgBaselineECEF( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -413,8 +330,7 @@ public void test5() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -422,8 +338,7 @@ public void test5() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -431,9 +346,7 @@ public void test5() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326829000 + "'", - value.equals(BigInteger.valueOf(326829000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326829000 + "'", value.equals(BigInteger.valueOf( 326829000L ) ) ); } else { value = value.longValue(); expected = 326829000L; @@ -441,9 +354,7 @@ public void test5() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -1154883 + "'", - value.equals(BigInteger.valueOf(-1154883L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -1154883 + "'", value.equals(BigInteger.valueOf( -1154883L ) ) ); } else { value = value.longValue(); expected = -1154883L; @@ -451,9 +362,7 @@ public void test5() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + 1326941 + "'", - value.equals(BigInteger.valueOf(1326941L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + 1326941 + "'", value.equals(BigInteger.valueOf( 1326941L ) ) ); } else { value = value.longValue(); expected = 1326941L; @@ -461,9 +370,7 @@ public void test5() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + 630626 + "'", - value.equals(BigInteger.valueOf(630626L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + 630626 + "'", value.equals(BigInteger.valueOf( 630626L ) ) ); } else { value = value.longValue(); expected = 630626L; diff --git a/java/test/auto_check_sbp_navigation_MsgBaselineHeadingDepATest.java b/java/test/auto_check_sbp_navigation_MsgBaselineHeadingDepATest.java index 892a6b894..b76db60bb 100644 --- a/java/test/auto_check_sbp_navigation_MsgBaselineHeadingDepATest.java +++ b/java/test/auto_check_sbp_navigation_MsgBaselineHeadingDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgBaselineHeadingDepA.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgBaselineHeadingDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgBaselineHeadingDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgBaselineHeadingDepATest { @@ -29,30 +33,16 @@ public class auto_check_sbp_navigation_MsgBaselineHeadingDepATest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_navigation_MsgBaselineHeadingDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 82, - (byte) 109, - (byte) 88, - (byte) 176, - (byte) 68, - (byte) 14, - (byte) 82, - (byte) 203, - (byte) 186, - (byte) 58, - }; - SBPMessage sbp = new SBPMessage(0xce7c, 0x207, payload); - MsgBaselineHeadingDepA msg = new MsgBaselineHeadingDepA(sbp); + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineHeadingDepATest.test1"); + byte[] payload = new byte[] {(byte)82,(byte)109,(byte)88,(byte)176,(byte)68,(byte)14,(byte)82,(byte)203,(byte)186,(byte)58, }; + SBPMessage sbp = new SBPMessage( 0xce7c, 0x207, payload ); + MsgBaselineHeadingDepA msg = new MsgBaselineHeadingDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 58 + "'", value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -60,9 +50,7 @@ public void test1() throws Throwable { } value = msg.heading; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.heading + "' != '" + 3411152452L + "'", - value.equals(new BigInteger("3411152452"))); + org.junit.Assert.assertTrue("'" + msg.heading + "' != '" + 3411152452L + "'", value.equals( new BigInteger( "3411152452" ) ) ); } else { value = value.longValue(); expected = 3411152452L; @@ -70,9 +58,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -80,9 +66,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2958585170L + "'", - value.equals(new BigInteger("2958585170"))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2958585170L + "'", value.equals( new BigInteger( "2958585170" ) ) ); } else { value = value.longValue(); expected = 2958585170L; diff --git a/java/test/auto_check_sbp_navigation_MsgBaselineNEDDepATest.java b/java/test/auto_check_sbp_navigation_MsgBaselineNEDDepATest.java index 6f46bc6ed..fc8342148 100644 --- a/java/test/auto_check_sbp_navigation_MsgBaselineNEDDepATest.java +++ b/java/test/auto_check_sbp_navigation_MsgBaselineNEDDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgBaselineNEDDepA.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgBaselineNEDDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgBaselineNEDDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgBaselineNEDDepATest { @@ -30,40 +34,15 @@ public class auto_check_sbp_navigation_MsgBaselineNEDDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 20, - (byte) 46, - (byte) 39, - (byte) 0, - (byte) 243, - (byte) 134, - (byte) 254, - (byte) 255, - (byte) 234, - (byte) 153, - (byte) 255, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x203, payload); - MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA(sbp); + byte[] payload = new byte[] {(byte)20,(byte)46,(byte)39,(byte)0,(byte)243,(byte)134,(byte)254,(byte)255,(byte)234,(byte)153,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x203, payload ); + MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -71,9 +50,7 @@ public void test1() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + -26134 + "'", - value.equals(BigInteger.valueOf(-26134L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + -26134 + "'", value.equals(BigInteger.valueOf( -26134L ) ) ); } else { value = value.longValue(); expected = -26134L; @@ -81,8 +58,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -90,9 +66,7 @@ public void test1() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -100,9 +74,7 @@ public void test1() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + -96525 + "'", - value.equals(BigInteger.valueOf(-96525L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + -96525 + "'", value.equals(BigInteger.valueOf( -96525L ) ) ); } else { value = value.longValue(); expected = -96525L; @@ -110,8 +82,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -119,9 +90,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567700 + "'", - value.equals(BigInteger.valueOf(2567700L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567700 + "'", value.equals(BigInteger.valueOf( 2567700L ) ) ); } else { value = value.longValue(); expected = 2567700L; @@ -129,9 +98,7 @@ public void test1() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -145,40 +112,15 @@ public void test1() throws Throwable { public void test2() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDDepATest.test2"); - byte[] payload = - new byte[] { - (byte) 120, - (byte) 46, - (byte) 39, - (byte) 0, - (byte) 139, - (byte) 134, - (byte) 254, - (byte) 255, - (byte) 109, - (byte) 155, - (byte) 255, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x203, payload); - MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA(sbp); + byte[] payload = new byte[] {(byte)120,(byte)46,(byte)39,(byte)0,(byte)139,(byte)134,(byte)254,(byte)255,(byte)109,(byte)155,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x203, payload ); + MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -186,9 +128,7 @@ public void test2() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + -25747 + "'", - value.equals(BigInteger.valueOf(-25747L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + -25747 + "'", value.equals(BigInteger.valueOf( -25747L ) ) ); } else { value = value.longValue(); expected = -25747L; @@ -196,8 +136,7 @@ public void test2() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -205,9 +144,7 @@ public void test2() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -215,9 +152,7 @@ public void test2() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + -96629 + "'", - value.equals(BigInteger.valueOf(-96629L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + -96629 + "'", value.equals(BigInteger.valueOf( -96629L ) ) ); } else { value = value.longValue(); expected = -96629L; @@ -225,8 +160,7 @@ public void test2() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -234,9 +168,7 @@ public void test2() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567800 + "'", - value.equals(BigInteger.valueOf(2567800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567800 + "'", value.equals(BigInteger.valueOf( 2567800L ) ) ); } else { value = value.longValue(); expected = 2567800L; @@ -244,9 +176,7 @@ public void test2() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -260,40 +190,15 @@ public void test2() throws Throwable { public void test3() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDDepATest.test3"); - byte[] payload = - new byte[] { - (byte) 220, - (byte) 46, - (byte) 39, - (byte) 0, - (byte) 37, - (byte) 134, - (byte) 254, - (byte) 255, - (byte) 240, - (byte) 156, - (byte) 255, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x203, payload); - MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA(sbp); + byte[] payload = new byte[] {(byte)220,(byte)46,(byte)39,(byte)0,(byte)37,(byte)134,(byte)254,(byte)255,(byte)240,(byte)156,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x203, payload ); + MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -301,9 +206,7 @@ public void test3() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + -25360 + "'", - value.equals(BigInteger.valueOf(-25360L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + -25360 + "'", value.equals(BigInteger.valueOf( -25360L ) ) ); } else { value = value.longValue(); expected = -25360L; @@ -311,8 +214,7 @@ public void test3() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -320,9 +222,7 @@ public void test3() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -330,9 +230,7 @@ public void test3() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + -96731 + "'", - value.equals(BigInteger.valueOf(-96731L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + -96731 + "'", value.equals(BigInteger.valueOf( -96731L ) ) ); } else { value = value.longValue(); expected = -96731L; @@ -340,8 +238,7 @@ public void test3() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -349,9 +246,7 @@ public void test3() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567900 + "'", - value.equals(BigInteger.valueOf(2567900L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567900 + "'", value.equals(BigInteger.valueOf( 2567900L ) ) ); } else { value = value.longValue(); expected = 2567900L; @@ -359,9 +254,7 @@ public void test3() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -375,40 +268,15 @@ public void test3() throws Throwable { public void test4() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDDepATest.test4"); - byte[] payload = - new byte[] { - (byte) 64, - (byte) 47, - (byte) 39, - (byte) 0, - (byte) 193, - (byte) 133, - (byte) 254, - (byte) 255, - (byte) 115, - (byte) 158, - (byte) 255, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x203, payload); - MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA(sbp); + byte[] payload = new byte[] {(byte)64,(byte)47,(byte)39,(byte)0,(byte)193,(byte)133,(byte)254,(byte)255,(byte)115,(byte)158,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x203, payload ); + MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -416,9 +284,7 @@ public void test4() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + -24973 + "'", - value.equals(BigInteger.valueOf(-24973L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + -24973 + "'", value.equals(BigInteger.valueOf( -24973L ) ) ); } else { value = value.longValue(); expected = -24973L; @@ -426,8 +292,7 @@ public void test4() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -435,9 +300,7 @@ public void test4() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -445,9 +308,7 @@ public void test4() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + -96831 + "'", - value.equals(BigInteger.valueOf(-96831L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + -96831 + "'", value.equals(BigInteger.valueOf( -96831L ) ) ); } else { value = value.longValue(); expected = -96831L; @@ -455,8 +316,7 @@ public void test4() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -464,9 +324,7 @@ public void test4() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2568000 + "'", - value.equals(BigInteger.valueOf(2568000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2568000 + "'", value.equals(BigInteger.valueOf( 2568000L ) ) ); } else { value = value.longValue(); expected = 2568000L; @@ -474,9 +332,7 @@ public void test4() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -490,40 +346,15 @@ public void test4() throws Throwable { public void test5() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDDepATest.test5"); - byte[] payload = - new byte[] { - (byte) 164, - (byte) 47, - (byte) 39, - (byte) 0, - (byte) 93, - (byte) 133, - (byte) 254, - (byte) 255, - (byte) 246, - (byte) 159, - (byte) 255, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x203, payload); - MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA(sbp); + byte[] payload = new byte[] {(byte)164,(byte)47,(byte)39,(byte)0,(byte)93,(byte)133,(byte)254,(byte)255,(byte)246,(byte)159,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x203, payload ); + MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -531,9 +362,7 @@ public void test5() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + -24586 + "'", - value.equals(BigInteger.valueOf(-24586L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + -24586 + "'", value.equals(BigInteger.valueOf( -24586L ) ) ); } else { value = value.longValue(); expected = -24586L; @@ -541,8 +370,7 @@ public void test5() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -550,9 +378,7 @@ public void test5() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -560,9 +386,7 @@ public void test5() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + -96931 + "'", - value.equals(BigInteger.valueOf(-96931L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + -96931 + "'", value.equals(BigInteger.valueOf( -96931L ) ) ); } else { value = value.longValue(); expected = -96931L; @@ -570,8 +394,7 @@ public void test5() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -579,9 +402,7 @@ public void test5() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2568100 + "'", - value.equals(BigInteger.valueOf(2568100L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2568100 + "'", value.equals(BigInteger.valueOf( 2568100L ) ) ); } else { value = value.longValue(); expected = 2568100L; @@ -589,9 +410,7 @@ public void test5() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -605,23 +424,15 @@ public void test5() throws Throwable { public void test6() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDDepATest.test6"); - byte[] payload = - new byte[] { - (byte) 156, (byte) 21, (byte) 69, (byte) 24, (byte) 130, (byte) 246, (byte) 255, - (byte) 255, (byte) 241, (byte) 4, (byte) 0, (byte) 0, (byte) 35, (byte) 196, - (byte) 255, (byte) 255, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 6, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x203, payload); - MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA(sbp); + byte[] payload = new byte[] {(byte)156,(byte)21,(byte)69,(byte)24,(byte)130,(byte)246,(byte)255,(byte)255,(byte)241,(byte)4,(byte)0,(byte)0,(byte)35,(byte)196,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)6,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x203, payload ); + MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + -15325 + "'", - value.equals(BigInteger.valueOf(-15325L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + -15325 + "'", value.equals(BigInteger.valueOf( -15325L ) ) ); } else { value = value.longValue(); expected = -15325L; @@ -629,8 +440,7 @@ public void test6() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + 1265 + "'", value.equals(BigInteger.valueOf(1265L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + 1265 + "'", value.equals(BigInteger.valueOf( 1265L ) ) ); } else { value = value.longValue(); expected = 1265L; @@ -638,8 +448,7 @@ public void test6() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -647,9 +456,7 @@ public void test6() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -657,8 +464,7 @@ public void test6() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + -2430 + "'", value.equals(BigInteger.valueOf(-2430L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + -2430 + "'", value.equals(BigInteger.valueOf( -2430L ) ) ); } else { value = value.longValue(); expected = -2430L; @@ -666,8 +472,7 @@ public void test6() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -675,9 +480,7 @@ public void test6() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407180700 + "'", - value.equals(BigInteger.valueOf(407180700L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407180700 + "'", value.equals(BigInteger.valueOf( 407180700L ) ) ); } else { value = value.longValue(); expected = 407180700L; @@ -685,9 +488,7 @@ public void test6() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -701,23 +502,15 @@ public void test6() throws Throwable { public void test7() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDDepATest.test7"); - byte[] payload = - new byte[] { - (byte) 0, (byte) 22, (byte) 69, (byte) 24, (byte) 130, (byte) 246, (byte) 255, - (byte) 255, (byte) 241, (byte) 4, (byte) 0, (byte) 0, (byte) 35, (byte) 196, - (byte) 255, (byte) 255, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 6, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x203, payload); - MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA(sbp); + byte[] payload = new byte[] {(byte)0,(byte)22,(byte)69,(byte)24,(byte)130,(byte)246,(byte)255,(byte)255,(byte)241,(byte)4,(byte)0,(byte)0,(byte)35,(byte)196,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)6,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x203, payload ); + MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + -15325 + "'", - value.equals(BigInteger.valueOf(-15325L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + -15325 + "'", value.equals(BigInteger.valueOf( -15325L ) ) ); } else { value = value.longValue(); expected = -15325L; @@ -725,8 +518,7 @@ public void test7() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + 1265 + "'", value.equals(BigInteger.valueOf(1265L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + 1265 + "'", value.equals(BigInteger.valueOf( 1265L ) ) ); } else { value = value.longValue(); expected = 1265L; @@ -734,8 +526,7 @@ public void test7() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -743,9 +534,7 @@ public void test7() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -753,8 +542,7 @@ public void test7() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + -2430 + "'", value.equals(BigInteger.valueOf(-2430L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + -2430 + "'", value.equals(BigInteger.valueOf( -2430L ) ) ); } else { value = value.longValue(); expected = -2430L; @@ -762,8 +550,7 @@ public void test7() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -771,9 +558,7 @@ public void test7() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407180800 + "'", - value.equals(BigInteger.valueOf(407180800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407180800 + "'", value.equals(BigInteger.valueOf( 407180800L ) ) ); } else { value = value.longValue(); expected = 407180800L; @@ -781,9 +566,7 @@ public void test7() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -797,23 +580,15 @@ public void test7() throws Throwable { public void test8() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDDepATest.test8"); - byte[] payload = - new byte[] { - (byte) 100, (byte) 22, (byte) 69, (byte) 24, (byte) 32, (byte) 251, (byte) 255, - (byte) 255, (byte) 199, (byte) 11, (byte) 0, (byte) 0, (byte) 57, (byte) 161, - (byte) 255, (byte) 255, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 6, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x203, payload); - MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA(sbp); + byte[] payload = new byte[] {(byte)100,(byte)22,(byte)69,(byte)24,(byte)32,(byte)251,(byte)255,(byte)255,(byte)199,(byte)11,(byte)0,(byte)0,(byte)57,(byte)161,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)6,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x203, payload ); + MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + -24263 + "'", - value.equals(BigInteger.valueOf(-24263L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + -24263 + "'", value.equals(BigInteger.valueOf( -24263L ) ) ); } else { value = value.longValue(); expected = -24263L; @@ -821,8 +596,7 @@ public void test8() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + 3015 + "'", value.equals(BigInteger.valueOf(3015L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + 3015 + "'", value.equals(BigInteger.valueOf( 3015L ) ) ); } else { value = value.longValue(); expected = 3015L; @@ -830,8 +604,7 @@ public void test8() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -839,9 +612,7 @@ public void test8() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -849,8 +620,7 @@ public void test8() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + -1248 + "'", value.equals(BigInteger.valueOf(-1248L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + -1248 + "'", value.equals(BigInteger.valueOf( -1248L ) ) ); } else { value = value.longValue(); expected = -1248L; @@ -858,8 +628,7 @@ public void test8() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -867,9 +636,7 @@ public void test8() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407180900 + "'", - value.equals(BigInteger.valueOf(407180900L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407180900 + "'", value.equals(BigInteger.valueOf( 407180900L ) ) ); } else { value = value.longValue(); expected = 407180900L; @@ -877,9 +644,7 @@ public void test8() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -893,23 +658,15 @@ public void test8() throws Throwable { public void test9() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDDepATest.test9"); - byte[] payload = - new byte[] { - (byte) 200, (byte) 22, (byte) 69, (byte) 24, (byte) 33, (byte) 251, (byte) 255, - (byte) 255, (byte) 199, (byte) 11, (byte) 0, (byte) 0, (byte) 54, (byte) 161, - (byte) 255, (byte) 255, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 6, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x203, payload); - MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA(sbp); + byte[] payload = new byte[] {(byte)200,(byte)22,(byte)69,(byte)24,(byte)33,(byte)251,(byte)255,(byte)255,(byte)199,(byte)11,(byte)0,(byte)0,(byte)54,(byte)161,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)6,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x203, payload ); + MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + -24266 + "'", - value.equals(BigInteger.valueOf(-24266L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + -24266 + "'", value.equals(BigInteger.valueOf( -24266L ) ) ); } else { value = value.longValue(); expected = -24266L; @@ -917,8 +674,7 @@ public void test9() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + 3015 + "'", value.equals(BigInteger.valueOf(3015L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + 3015 + "'", value.equals(BigInteger.valueOf( 3015L ) ) ); } else { value = value.longValue(); expected = 3015L; @@ -926,8 +682,7 @@ public void test9() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -935,9 +690,7 @@ public void test9() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -945,8 +698,7 @@ public void test9() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + -1247 + "'", value.equals(BigInteger.valueOf(-1247L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + -1247 + "'", value.equals(BigInteger.valueOf( -1247L ) ) ); } else { value = value.longValue(); expected = -1247L; @@ -954,8 +706,7 @@ public void test9() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -963,9 +714,7 @@ public void test9() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407181000 + "'", - value.equals(BigInteger.valueOf(407181000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407181000 + "'", value.equals(BigInteger.valueOf( 407181000L ) ) ); } else { value = value.longValue(); expected = 407181000L; @@ -973,9 +722,7 @@ public void test9() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -989,23 +736,15 @@ public void test9() throws Throwable { public void test10() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDDepATest.test10"); - byte[] payload = - new byte[] { - (byte) 44, (byte) 23, (byte) 69, (byte) 24, (byte) 110, (byte) 6, (byte) 0, - (byte) 0, (byte) 55, (byte) 8, (byte) 0, (byte) 0, (byte) 160, (byte) 166, - (byte) 255, (byte) 255, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 6, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x203, payload); - MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA(sbp); + byte[] payload = new byte[] {(byte)44,(byte)23,(byte)69,(byte)24,(byte)110,(byte)6,(byte)0,(byte)0,(byte)55,(byte)8,(byte)0,(byte)0,(byte)160,(byte)166,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)6,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x203, payload ); + MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + -22880 + "'", - value.equals(BigInteger.valueOf(-22880L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + -22880 + "'", value.equals(BigInteger.valueOf( -22880L ) ) ); } else { value = value.longValue(); expected = -22880L; @@ -1013,8 +752,7 @@ public void test10() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + 2103 + "'", value.equals(BigInteger.valueOf(2103L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + 2103 + "'", value.equals(BigInteger.valueOf( 2103L ) ) ); } else { value = value.longValue(); expected = 2103L; @@ -1022,8 +760,7 @@ public void test10() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1031,9 +768,7 @@ public void test10() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1041,8 +776,7 @@ public void test10() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + 1646 + "'", value.equals(BigInteger.valueOf(1646L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + 1646 + "'", value.equals(BigInteger.valueOf( 1646L ) ) ); } else { value = value.longValue(); expected = 1646L; @@ -1050,8 +784,7 @@ public void test10() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1059,9 +792,7 @@ public void test10() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407181100 + "'", - value.equals(BigInteger.valueOf(407181100L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407181100 + "'", value.equals(BigInteger.valueOf( 407181100L ) ) ); } else { value = value.longValue(); expected = 407181100L; @@ -1069,9 +800,7 @@ public void test10() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1085,23 +814,15 @@ public void test10() throws Throwable { public void test11() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDDepATest.test11"); - byte[] payload = - new byte[] { - (byte) 144, (byte) 23, (byte) 69, (byte) 24, (byte) 110, (byte) 6, (byte) 0, - (byte) 0, (byte) 54, (byte) 8, (byte) 0, (byte) 0, (byte) 160, (byte) 166, - (byte) 255, (byte) 255, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 6, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x203, payload); - MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA(sbp); + byte[] payload = new byte[] {(byte)144,(byte)23,(byte)69,(byte)24,(byte)110,(byte)6,(byte)0,(byte)0,(byte)54,(byte)8,(byte)0,(byte)0,(byte)160,(byte)166,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)6,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x203, payload ); + MsgBaselineNEDDepA msg = new MsgBaselineNEDDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + -22880 + "'", - value.equals(BigInteger.valueOf(-22880L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + -22880 + "'", value.equals(BigInteger.valueOf( -22880L ) ) ); } else { value = value.longValue(); expected = -22880L; @@ -1109,8 +830,7 @@ public void test11() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + 2102 + "'", value.equals(BigInteger.valueOf(2102L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + 2102 + "'", value.equals(BigInteger.valueOf( 2102L ) ) ); } else { value = value.longValue(); expected = 2102L; @@ -1118,8 +838,7 @@ public void test11() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1127,9 +846,7 @@ public void test11() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1137,8 +854,7 @@ public void test11() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + 1646 + "'", value.equals(BigInteger.valueOf(1646L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + 1646 + "'", value.equals(BigInteger.valueOf( 1646L ) ) ); } else { value = value.longValue(); expected = 1646L; @@ -1146,8 +862,7 @@ public void test11() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1155,9 +870,7 @@ public void test11() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407181200 + "'", - value.equals(BigInteger.valueOf(407181200L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407181200 + "'", value.equals(BigInteger.valueOf( 407181200L ) ) ); } else { value = value.longValue(); expected = 407181200L; @@ -1165,9 +878,7 @@ public void test11() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; diff --git a/java/test/auto_check_sbp_navigation_MsgBaselineNEDTest.java b/java/test/auto_check_sbp_navigation_MsgBaselineNEDTest.java index 7f53b3022..92536683f 100644 --- a/java/test/auto_check_sbp_navigation_MsgBaselineNEDTest.java +++ b/java/test/auto_check_sbp_navigation_MsgBaselineNEDTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgBaselineNED.yaml by generate.py. Do not modify by -// hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgBaselineNED.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgBaselineNED; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgBaselineNEDTest { @@ -30,40 +34,15 @@ public class auto_check_sbp_navigation_MsgBaselineNEDTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDTest.test1"); - byte[] payload = - new byte[] { - (byte) 40, - (byte) 244, - (byte) 122, - (byte) 19, - (byte) 201, - (byte) 115, - (byte) 12, - (byte) 0, - (byte) 179, - (byte) 88, - (byte) 230, - (byte) 255, - (byte) 153, - (byte) 125, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 14, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20c, payload); - MsgBaselineNED msg = new MsgBaselineNED(sbp); + byte[] payload = new byte[] {(byte)40,(byte)244,(byte)122,(byte)19,(byte)201,(byte)115,(byte)12,(byte)0,(byte)179,(byte)88,(byte)230,(byte)255,(byte)153,(byte)125,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)14,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20c, payload ); + MsgBaselineNED msg = new MsgBaselineNED( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + 32153 + "'", value.equals(BigInteger.valueOf(32153L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + 32153 + "'", value.equals(BigInteger.valueOf( 32153L ) ) ); } else { value = value.longValue(); expected = 32153L; @@ -71,9 +50,7 @@ public void test1() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + -1681229 + "'", - value.equals(BigInteger.valueOf(-1681229L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + -1681229 + "'", value.equals(BigInteger.valueOf( -1681229L ) ) ); } else { value = value.longValue(); expected = -1681229L; @@ -81,8 +58,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -90,9 +66,7 @@ public void test1() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -100,9 +74,7 @@ public void test1() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + 816073 + "'", - value.equals(BigInteger.valueOf(816073L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + 816073 + "'", value.equals(BigInteger.valueOf( 816073L ) ) ); } else { value = value.longValue(); expected = 816073L; @@ -110,8 +82,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 14 + "'", value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -119,9 +90,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326825000 + "'", - value.equals(BigInteger.valueOf(326825000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326825000 + "'", value.equals(BigInteger.valueOf( 326825000L ) ) ); } else { value = value.longValue(); expected = 326825000L; @@ -129,9 +98,7 @@ public void test1() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -145,40 +112,15 @@ public void test1() throws Throwable { public void test2() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDTest.test2"); - byte[] payload = - new byte[] { - (byte) 16, - (byte) 248, - (byte) 122, - (byte) 19, - (byte) 98, - (byte) 115, - (byte) 12, - (byte) 0, - (byte) 194, - (byte) 88, - (byte) 230, - (byte) 255, - (byte) 110, - (byte) 127, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 15, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20c, payload); - MsgBaselineNED msg = new MsgBaselineNED(sbp); + byte[] payload = new byte[] {(byte)16,(byte)248,(byte)122,(byte)19,(byte)98,(byte)115,(byte)12,(byte)0,(byte)194,(byte)88,(byte)230,(byte)255,(byte)110,(byte)127,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)15,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20c, payload ); + MsgBaselineNED msg = new MsgBaselineNED( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + 32622 + "'", value.equals(BigInteger.valueOf(32622L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + 32622 + "'", value.equals(BigInteger.valueOf( 32622L ) ) ); } else { value = value.longValue(); expected = 32622L; @@ -186,9 +128,7 @@ public void test2() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + -1681214 + "'", - value.equals(BigInteger.valueOf(-1681214L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + -1681214 + "'", value.equals(BigInteger.valueOf( -1681214L ) ) ); } else { value = value.longValue(); expected = -1681214L; @@ -196,8 +136,7 @@ public void test2() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -205,9 +144,7 @@ public void test2() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -215,9 +152,7 @@ public void test2() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + 815970 + "'", - value.equals(BigInteger.valueOf(815970L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + 815970 + "'", value.equals(BigInteger.valueOf( 815970L ) ) ); } else { value = value.longValue(); expected = 815970L; @@ -225,8 +160,7 @@ public void test2() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -234,9 +168,7 @@ public void test2() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326826000 + "'", - value.equals(BigInteger.valueOf(326826000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326826000 + "'", value.equals(BigInteger.valueOf( 326826000L ) ) ); } else { value = value.longValue(); expected = 326826000L; @@ -244,9 +176,7 @@ public void test2() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -260,40 +190,15 @@ public void test2() throws Throwable { public void test3() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDTest.test3"); - byte[] payload = - new byte[] { - (byte) 248, - (byte) 251, - (byte) 122, - (byte) 19, - (byte) 143, - (byte) 114, - (byte) 12, - (byte) 0, - (byte) 173, - (byte) 88, - (byte) 230, - (byte) 255, - (byte) 238, - (byte) 127, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 15, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20c, payload); - MsgBaselineNED msg = new MsgBaselineNED(sbp); + byte[] payload = new byte[] {(byte)248,(byte)251,(byte)122,(byte)19,(byte)143,(byte)114,(byte)12,(byte)0,(byte)173,(byte)88,(byte)230,(byte)255,(byte)238,(byte)127,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)15,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20c, payload ); + MsgBaselineNED msg = new MsgBaselineNED( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + 32750 + "'", value.equals(BigInteger.valueOf(32750L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + 32750 + "'", value.equals(BigInteger.valueOf( 32750L ) ) ); } else { value = value.longValue(); expected = 32750L; @@ -301,9 +206,7 @@ public void test3() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + -1681235 + "'", - value.equals(BigInteger.valueOf(-1681235L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + -1681235 + "'", value.equals(BigInteger.valueOf( -1681235L ) ) ); } else { value = value.longValue(); expected = -1681235L; @@ -311,8 +214,7 @@ public void test3() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -320,9 +222,7 @@ public void test3() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -330,9 +230,7 @@ public void test3() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + 815759 + "'", - value.equals(BigInteger.valueOf(815759L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + 815759 + "'", value.equals(BigInteger.valueOf( 815759L ) ) ); } else { value = value.longValue(); expected = 815759L; @@ -340,8 +238,7 @@ public void test3() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -349,9 +246,7 @@ public void test3() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326827000 + "'", - value.equals(BigInteger.valueOf(326827000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326827000 + "'", value.equals(BigInteger.valueOf( 326827000L ) ) ); } else { value = value.longValue(); expected = 326827000L; @@ -359,9 +254,7 @@ public void test3() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -375,40 +268,15 @@ public void test3() throws Throwable { public void test4() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDTest.test4"); - byte[] payload = - new byte[] { - (byte) 224, - (byte) 255, - (byte) 122, - (byte) 19, - (byte) 86, - (byte) 112, - (byte) 12, - (byte) 0, - (byte) 51, - (byte) 88, - (byte) 230, - (byte) 255, - (byte) 47, - (byte) 127, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 15, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20c, payload); - MsgBaselineNED msg = new MsgBaselineNED(sbp); + byte[] payload = new byte[] {(byte)224,(byte)255,(byte)122,(byte)19,(byte)86,(byte)112,(byte)12,(byte)0,(byte)51,(byte)88,(byte)230,(byte)255,(byte)47,(byte)127,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)15,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20c, payload ); + MsgBaselineNED msg = new MsgBaselineNED( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + 32559 + "'", value.equals(BigInteger.valueOf(32559L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + 32559 + "'", value.equals(BigInteger.valueOf( 32559L ) ) ); } else { value = value.longValue(); expected = 32559L; @@ -416,9 +284,7 @@ public void test4() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + -1681357 + "'", - value.equals(BigInteger.valueOf(-1681357L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + -1681357 + "'", value.equals(BigInteger.valueOf( -1681357L ) ) ); } else { value = value.longValue(); expected = -1681357L; @@ -426,8 +292,7 @@ public void test4() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -435,9 +300,7 @@ public void test4() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -445,9 +308,7 @@ public void test4() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + 815190 + "'", - value.equals(BigInteger.valueOf(815190L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + 815190 + "'", value.equals(BigInteger.valueOf( 815190L ) ) ); } else { value = value.longValue(); expected = 815190L; @@ -455,8 +316,7 @@ public void test4() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -464,9 +324,7 @@ public void test4() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326828000 + "'", - value.equals(BigInteger.valueOf(326828000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326828000 + "'", value.equals(BigInteger.valueOf( 326828000L ) ) ); } else { value = value.longValue(); expected = 326828000L; @@ -474,9 +332,7 @@ public void test4() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -490,40 +346,15 @@ public void test4() throws Throwable { public void test5() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgBaselineNEDTest.test5"); - byte[] payload = - new byte[] { - (byte) 200, - (byte) 3, - (byte) 123, - (byte) 19, - (byte) 214, - (byte) 110, - (byte) 12, - (byte) 0, - (byte) 220, - (byte) 87, - (byte) 230, - (byte) 255, - (byte) 165, - (byte) 126, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 15, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20c, payload); - MsgBaselineNED msg = new MsgBaselineNED(sbp); + byte[] payload = new byte[] {(byte)200,(byte)3,(byte)123,(byte)19,(byte)214,(byte)110,(byte)12,(byte)0,(byte)220,(byte)87,(byte)230,(byte)255,(byte)165,(byte)126,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)15,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20c, payload ); + MsgBaselineNED msg = new MsgBaselineNED( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.d; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.d + "' != '" + 32421 + "'", value.equals(BigInteger.valueOf(32421L))); + org.junit.Assert.assertTrue("'" + msg.d + "' != '" + 32421 + "'", value.equals(BigInteger.valueOf( 32421L ) ) ); } else { value = value.longValue(); expected = 32421L; @@ -531,9 +362,7 @@ public void test5() throws Throwable { } value = msg.e; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.e + "' != '" + -1681444 + "'", - value.equals(BigInteger.valueOf(-1681444L))); + org.junit.Assert.assertTrue("'" + msg.e + "' != '" + -1681444 + "'", value.equals(BigInteger.valueOf( -1681444L ) ) ); } else { value = value.longValue(); expected = -1681444L; @@ -541,8 +370,7 @@ public void test5() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -550,9 +378,7 @@ public void test5() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -560,9 +386,7 @@ public void test5() throws Throwable { } value = msg.n; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n + "' != '" + 814806 + "'", - value.equals(BigInteger.valueOf(814806L))); + org.junit.Assert.assertTrue("'" + msg.n + "' != '" + 814806 + "'", value.equals(BigInteger.valueOf( 814806L ) ) ); } else { value = value.longValue(); expected = 814806L; @@ -570,8 +394,7 @@ public void test5() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -579,9 +402,7 @@ public void test5() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326829000 + "'", - value.equals(BigInteger.valueOf(326829000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326829000 + "'", value.equals(BigInteger.valueOf( 326829000L ) ) ); } else { value = value.longValue(); expected = 326829000L; @@ -589,9 +410,7 @@ public void test5() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; diff --git a/java/test/auto_check_sbp_navigation_MsgDopsDepATest.java b/java/test/auto_check_sbp_navigation_MsgDopsDepATest.java index 1396d834c..b18f2705d 100644 --- a/java/test/auto_check_sbp_navigation_MsgDopsDepATest.java +++ b/java/test/auto_check_sbp_navigation_MsgDopsDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgDopsDepA.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgDopsDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgDopsDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgDopsDepATest { @@ -27,21 +32,17 @@ public class auto_check_sbp_navigation_MsgDopsDepATest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 8, (byte) 48, (byte) 39, (byte) 0, (byte) 180, (byte) 0, (byte) 190, - (byte) 0, (byte) 170, (byte) 0, (byte) 160, (byte) 0, (byte) 150, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x206, payload); - MsgDopsDepA msg = new MsgDopsDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test1"); + byte[] payload = new byte[] {(byte)8,(byte)48,(byte)39,(byte)0,(byte)180,(byte)0,(byte)190,(byte)0,(byte)170,(byte)0,(byte)160,(byte)0,(byte)150,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x206, payload ); + MsgDopsDepA msg = new MsgDopsDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.gdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gdop + "' != '" + 180 + "'", value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.gdop + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -49,8 +50,7 @@ public void test1() throws Throwable { } value = msg.hdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hdop + "' != '" + 160 + "'", value.equals(BigInteger.valueOf(160L))); + org.junit.Assert.assertTrue("'" + msg.hdop + "' != '" + 160 + "'", value.equals(BigInteger.valueOf( 160L ) ) ); } else { value = value.longValue(); expected = 160L; @@ -58,8 +58,7 @@ public void test1() throws Throwable { } value = msg.pdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pdop + "' != '" + 190 + "'", value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.pdop + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -67,8 +66,7 @@ public void test1() throws Throwable { } value = msg.tdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tdop + "' != '" + 170 + "'", value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.tdop + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -76,9 +74,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2568200 + "'", - value.equals(BigInteger.valueOf(2568200L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2568200 + "'", value.equals(BigInteger.valueOf( 2568200L ) ) ); } else { value = value.longValue(); expected = 2568200L; @@ -86,8 +82,7 @@ public void test1() throws Throwable { } value = msg.vdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vdop + "' != '" + 150 + "'", value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.vdop + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -99,21 +94,17 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test2"); - byte[] payload = - new byte[] { - (byte) 240, (byte) 51, (byte) 39, (byte) 0, (byte) 180, (byte) 0, (byte) 190, - (byte) 0, (byte) 170, (byte) 0, (byte) 160, (byte) 0, (byte) 150, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x206, payload); - MsgDopsDepA msg = new MsgDopsDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test2"); + byte[] payload = new byte[] {(byte)240,(byte)51,(byte)39,(byte)0,(byte)180,(byte)0,(byte)190,(byte)0,(byte)170,(byte)0,(byte)160,(byte)0,(byte)150,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x206, payload ); + MsgDopsDepA msg = new MsgDopsDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.gdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gdop + "' != '" + 180 + "'", value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.gdop + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -121,8 +112,7 @@ public void test2() throws Throwable { } value = msg.hdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hdop + "' != '" + 160 + "'", value.equals(BigInteger.valueOf(160L))); + org.junit.Assert.assertTrue("'" + msg.hdop + "' != '" + 160 + "'", value.equals(BigInteger.valueOf( 160L ) ) ); } else { value = value.longValue(); expected = 160L; @@ -130,8 +120,7 @@ public void test2() throws Throwable { } value = msg.pdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pdop + "' != '" + 190 + "'", value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.pdop + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -139,8 +128,7 @@ public void test2() throws Throwable { } value = msg.tdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tdop + "' != '" + 170 + "'", value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.tdop + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -148,9 +136,7 @@ public void test2() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2569200 + "'", - value.equals(BigInteger.valueOf(2569200L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2569200 + "'", value.equals(BigInteger.valueOf( 2569200L ) ) ); } else { value = value.longValue(); expected = 2569200L; @@ -158,8 +144,7 @@ public void test2() throws Throwable { } value = msg.vdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vdop + "' != '" + 150 + "'", value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.vdop + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -171,21 +156,17 @@ public void test2() throws Throwable { @Test public void test3() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test3"); - byte[] payload = - new byte[] { - (byte) 216, (byte) 55, (byte) 39, (byte) 0, (byte) 180, (byte) 0, (byte) 190, - (byte) 0, (byte) 170, (byte) 0, (byte) 160, (byte) 0, (byte) 150, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x206, payload); - MsgDopsDepA msg = new MsgDopsDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test3"); + byte[] payload = new byte[] {(byte)216,(byte)55,(byte)39,(byte)0,(byte)180,(byte)0,(byte)190,(byte)0,(byte)170,(byte)0,(byte)160,(byte)0,(byte)150,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x206, payload ); + MsgDopsDepA msg = new MsgDopsDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.gdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gdop + "' != '" + 180 + "'", value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.gdop + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -193,8 +174,7 @@ public void test3() throws Throwable { } value = msg.hdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hdop + "' != '" + 160 + "'", value.equals(BigInteger.valueOf(160L))); + org.junit.Assert.assertTrue("'" + msg.hdop + "' != '" + 160 + "'", value.equals(BigInteger.valueOf( 160L ) ) ); } else { value = value.longValue(); expected = 160L; @@ -202,8 +182,7 @@ public void test3() throws Throwable { } value = msg.pdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pdop + "' != '" + 190 + "'", value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.pdop + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -211,8 +190,7 @@ public void test3() throws Throwable { } value = msg.tdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tdop + "' != '" + 170 + "'", value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.tdop + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -220,9 +198,7 @@ public void test3() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2570200 + "'", - value.equals(BigInteger.valueOf(2570200L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2570200 + "'", value.equals(BigInteger.valueOf( 2570200L ) ) ); } else { value = value.longValue(); expected = 2570200L; @@ -230,8 +206,7 @@ public void test3() throws Throwable { } value = msg.vdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vdop + "' != '" + 150 + "'", value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.vdop + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -243,21 +218,17 @@ public void test3() throws Throwable { @Test public void test4() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test4"); - byte[] payload = - new byte[] { - (byte) 212, (byte) 157, (byte) 67, (byte) 24, (byte) 247, (byte) 0, (byte) 215, - (byte) 0, (byte) 123, (byte) 0, (byte) 17, (byte) 1, (byte) 44, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x206, payload); - MsgDopsDepA msg = new MsgDopsDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test4"); + byte[] payload = new byte[] {(byte)212,(byte)157,(byte)67,(byte)24,(byte)247,(byte)0,(byte)215,(byte)0,(byte)123,(byte)0,(byte)17,(byte)1,(byte)44,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x206, payload ); + MsgDopsDepA msg = new MsgDopsDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.gdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gdop + "' != '" + 247 + "'", value.equals(BigInteger.valueOf(247L))); + org.junit.Assert.assertTrue("'" + msg.gdop + "' != '" + 247 + "'", value.equals(BigInteger.valueOf( 247L ) ) ); } else { value = value.longValue(); expected = 247L; @@ -265,8 +236,7 @@ public void test4() throws Throwable { } value = msg.hdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hdop + "' != '" + 273 + "'", value.equals(BigInteger.valueOf(273L))); + org.junit.Assert.assertTrue("'" + msg.hdop + "' != '" + 273 + "'", value.equals(BigInteger.valueOf( 273L ) ) ); } else { value = value.longValue(); expected = 273L; @@ -274,8 +244,7 @@ public void test4() throws Throwable { } value = msg.pdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pdop + "' != '" + 215 + "'", value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.pdop + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -283,8 +252,7 @@ public void test4() throws Throwable { } value = msg.tdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tdop + "' != '" + 123 + "'", value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.tdop + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -292,9 +260,7 @@ public void test4() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084500 + "'", - value.equals(BigInteger.valueOf(407084500L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084500 + "'", value.equals(BigInteger.valueOf( 407084500L ) ) ); } else { value = value.longValue(); expected = 407084500L; @@ -302,8 +268,7 @@ public void test4() throws Throwable { } value = msg.vdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vdop + "' != '" + 44 + "'", value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.vdop + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -315,22 +280,17 @@ public void test4() throws Throwable { @Test public void test5() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test5"); - byte[] payload = - new byte[] { - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 255, (byte) 255, (byte) 255, - (byte) 255, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x206, payload); - MsgDopsDepA msg = new MsgDopsDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test5"); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)0,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x206, payload ); + MsgDopsDepA msg = new MsgDopsDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.gdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gdop + "' != '" + 65535 + "'", - value.equals(BigInteger.valueOf(65535L))); + org.junit.Assert.assertTrue("'" + msg.gdop + "' != '" + 65535 + "'", value.equals(BigInteger.valueOf( 65535L ) ) ); } else { value = value.longValue(); expected = 65535L; @@ -338,8 +298,7 @@ public void test5() throws Throwable { } value = msg.hdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hdop + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.hdop + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -347,9 +306,7 @@ public void test5() throws Throwable { } value = msg.pdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pdop + "' != '" + 65535 + "'", - value.equals(BigInteger.valueOf(65535L))); + org.junit.Assert.assertTrue("'" + msg.pdop + "' != '" + 65535 + "'", value.equals(BigInteger.valueOf( 65535L ) ) ); } else { value = value.longValue(); expected = 65535L; @@ -357,8 +314,7 @@ public void test5() throws Throwable { } value = msg.tdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tdop + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tdop + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -366,8 +322,7 @@ public void test5() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -375,8 +330,7 @@ public void test5() throws Throwable { } value = msg.vdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vdop + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.vdop + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -388,21 +342,17 @@ public void test5() throws Throwable { @Test public void test6() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test6"); - byte[] payload = - new byte[] { - (byte) 128, (byte) 165, (byte) 68, (byte) 24, (byte) 92, (byte) 1, (byte) 56, - (byte) 1, (byte) 155, (byte) 0, (byte) 125, (byte) 2, (byte) 113, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x206, payload); - MsgDopsDepA msg = new MsgDopsDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test6"); + byte[] payload = new byte[] {(byte)128,(byte)165,(byte)68,(byte)24,(byte)92,(byte)1,(byte)56,(byte)1,(byte)155,(byte)0,(byte)125,(byte)2,(byte)113,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x206, payload ); + MsgDopsDepA msg = new MsgDopsDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.gdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gdop + "' != '" + 348 + "'", value.equals(BigInteger.valueOf(348L))); + org.junit.Assert.assertTrue("'" + msg.gdop + "' != '" + 348 + "'", value.equals(BigInteger.valueOf( 348L ) ) ); } else { value = value.longValue(); expected = 348L; @@ -410,8 +360,7 @@ public void test6() throws Throwable { } value = msg.hdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hdop + "' != '" + 637 + "'", value.equals(BigInteger.valueOf(637L))); + org.junit.Assert.assertTrue("'" + msg.hdop + "' != '" + 637 + "'", value.equals(BigInteger.valueOf( 637L ) ) ); } else { value = value.longValue(); expected = 637L; @@ -419,8 +368,7 @@ public void test6() throws Throwable { } value = msg.pdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pdop + "' != '" + 312 + "'", value.equals(BigInteger.valueOf(312L))); + org.junit.Assert.assertTrue("'" + msg.pdop + "' != '" + 312 + "'", value.equals(BigInteger.valueOf( 312L ) ) ); } else { value = value.longValue(); expected = 312L; @@ -428,8 +376,7 @@ public void test6() throws Throwable { } value = msg.tdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tdop + "' != '" + 155 + "'", value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.tdop + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -437,9 +384,7 @@ public void test6() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407152000 + "'", - value.equals(BigInteger.valueOf(407152000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407152000 + "'", value.equals(BigInteger.valueOf( 407152000L ) ) ); } else { value = value.longValue(); expected = 407152000L; @@ -447,8 +392,7 @@ public void test6() throws Throwable { } value = msg.vdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vdop + "' != '" + 113 + "'", value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.vdop + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -460,21 +404,17 @@ public void test6() throws Throwable { @Test public void test7() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test7"); - byte[] payload = - new byte[] { - (byte) 104, (byte) 169, (byte) 68, (byte) 24, (byte) 92, (byte) 1, (byte) 55, - (byte) 1, (byte) 155, (byte) 0, (byte) 125, (byte) 2, (byte) 113, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x206, payload); - MsgDopsDepA msg = new MsgDopsDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test7"); + byte[] payload = new byte[] {(byte)104,(byte)169,(byte)68,(byte)24,(byte)92,(byte)1,(byte)55,(byte)1,(byte)155,(byte)0,(byte)125,(byte)2,(byte)113,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x206, payload ); + MsgDopsDepA msg = new MsgDopsDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.gdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gdop + "' != '" + 348 + "'", value.equals(BigInteger.valueOf(348L))); + org.junit.Assert.assertTrue("'" + msg.gdop + "' != '" + 348 + "'", value.equals(BigInteger.valueOf( 348L ) ) ); } else { value = value.longValue(); expected = 348L; @@ -482,8 +422,7 @@ public void test7() throws Throwable { } value = msg.hdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hdop + "' != '" + 637 + "'", value.equals(BigInteger.valueOf(637L))); + org.junit.Assert.assertTrue("'" + msg.hdop + "' != '" + 637 + "'", value.equals(BigInteger.valueOf( 637L ) ) ); } else { value = value.longValue(); expected = 637L; @@ -491,8 +430,7 @@ public void test7() throws Throwable { } value = msg.pdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pdop + "' != '" + 311 + "'", value.equals(BigInteger.valueOf(311L))); + org.junit.Assert.assertTrue("'" + msg.pdop + "' != '" + 311 + "'", value.equals(BigInteger.valueOf( 311L ) ) ); } else { value = value.longValue(); expected = 311L; @@ -500,8 +438,7 @@ public void test7() throws Throwable { } value = msg.tdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tdop + "' != '" + 155 + "'", value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.tdop + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -509,9 +446,7 @@ public void test7() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407153000 + "'", - value.equals(BigInteger.valueOf(407153000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407153000 + "'", value.equals(BigInteger.valueOf( 407153000L ) ) ); } else { value = value.longValue(); expected = 407153000L; @@ -519,8 +454,7 @@ public void test7() throws Throwable { } value = msg.vdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vdop + "' != '" + 113 + "'", value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.vdop + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -532,21 +466,17 @@ public void test7() throws Throwable { @Test public void test8() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test8"); - byte[] payload = - new byte[] { - (byte) 80, (byte) 173, (byte) 68, (byte) 24, (byte) 92, (byte) 1, (byte) 55, - (byte) 1, (byte) 155, (byte) 0, (byte) 125, (byte) 2, (byte) 112, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x206, payload); - MsgDopsDepA msg = new MsgDopsDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test8"); + byte[] payload = new byte[] {(byte)80,(byte)173,(byte)68,(byte)24,(byte)92,(byte)1,(byte)55,(byte)1,(byte)155,(byte)0,(byte)125,(byte)2,(byte)112,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x206, payload ); + MsgDopsDepA msg = new MsgDopsDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.gdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gdop + "' != '" + 348 + "'", value.equals(BigInteger.valueOf(348L))); + org.junit.Assert.assertTrue("'" + msg.gdop + "' != '" + 348 + "'", value.equals(BigInteger.valueOf( 348L ) ) ); } else { value = value.longValue(); expected = 348L; @@ -554,8 +484,7 @@ public void test8() throws Throwable { } value = msg.hdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hdop + "' != '" + 637 + "'", value.equals(BigInteger.valueOf(637L))); + org.junit.Assert.assertTrue("'" + msg.hdop + "' != '" + 637 + "'", value.equals(BigInteger.valueOf( 637L ) ) ); } else { value = value.longValue(); expected = 637L; @@ -563,8 +492,7 @@ public void test8() throws Throwable { } value = msg.pdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pdop + "' != '" + 311 + "'", value.equals(BigInteger.valueOf(311L))); + org.junit.Assert.assertTrue("'" + msg.pdop + "' != '" + 311 + "'", value.equals(BigInteger.valueOf( 311L ) ) ); } else { value = value.longValue(); expected = 311L; @@ -572,8 +500,7 @@ public void test8() throws Throwable { } value = msg.tdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tdop + "' != '" + 155 + "'", value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.tdop + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -581,9 +508,7 @@ public void test8() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407154000 + "'", - value.equals(BigInteger.valueOf(407154000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407154000 + "'", value.equals(BigInteger.valueOf( 407154000L ) ) ); } else { value = value.longValue(); expected = 407154000L; @@ -591,8 +516,7 @@ public void test8() throws Throwable { } value = msg.vdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vdop + "' != '" + 112 + "'", value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.vdop + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -604,21 +528,17 @@ public void test8() throws Throwable { @Test public void test9() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test9"); - byte[] payload = - new byte[] { - (byte) 56, (byte) 177, (byte) 68, (byte) 24, (byte) 92, (byte) 1, (byte) 55, - (byte) 1, (byte) 155, (byte) 0, (byte) 125, (byte) 2, (byte) 112, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x206, payload); - MsgDopsDepA msg = new MsgDopsDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsDepATest.test9"); + byte[] payload = new byte[] {(byte)56,(byte)177,(byte)68,(byte)24,(byte)92,(byte)1,(byte)55,(byte)1,(byte)155,(byte)0,(byte)125,(byte)2,(byte)112,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x206, payload ); + MsgDopsDepA msg = new MsgDopsDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.gdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gdop + "' != '" + 348 + "'", value.equals(BigInteger.valueOf(348L))); + org.junit.Assert.assertTrue("'" + msg.gdop + "' != '" + 348 + "'", value.equals(BigInteger.valueOf( 348L ) ) ); } else { value = value.longValue(); expected = 348L; @@ -626,8 +546,7 @@ public void test9() throws Throwable { } value = msg.hdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hdop + "' != '" + 637 + "'", value.equals(BigInteger.valueOf(637L))); + org.junit.Assert.assertTrue("'" + msg.hdop + "' != '" + 637 + "'", value.equals(BigInteger.valueOf( 637L ) ) ); } else { value = value.longValue(); expected = 637L; @@ -635,8 +554,7 @@ public void test9() throws Throwable { } value = msg.pdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pdop + "' != '" + 311 + "'", value.equals(BigInteger.valueOf(311L))); + org.junit.Assert.assertTrue("'" + msg.pdop + "' != '" + 311 + "'", value.equals(BigInteger.valueOf( 311L ) ) ); } else { value = value.longValue(); expected = 311L; @@ -644,8 +562,7 @@ public void test9() throws Throwable { } value = msg.tdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tdop + "' != '" + 155 + "'", value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.tdop + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -653,9 +570,7 @@ public void test9() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407155000 + "'", - value.equals(BigInteger.valueOf(407155000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407155000 + "'", value.equals(BigInteger.valueOf( 407155000L ) ) ); } else { value = value.longValue(); expected = 407155000L; @@ -663,8 +578,7 @@ public void test9() throws Throwable { } value = msg.vdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vdop + "' != '" + 112 + "'", value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.vdop + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; diff --git a/java/test/auto_check_sbp_navigation_MsgDopsTest.java b/java/test/auto_check_sbp_navigation_MsgDopsTest.java index fecef7569..13738a398 100644 --- a/java/test/auto_check_sbp_navigation_MsgDopsTest.java +++ b/java/test/auto_check_sbp_navigation_MsgDopsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgDops.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgDops.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgDops; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgDopsTest { @@ -27,34 +32,17 @@ public class auto_check_sbp_navigation_MsgDopsTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsTest.test1"); - byte[] payload = - new byte[] { - (byte) 100, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 2, - (byte) 0, - (byte) 6, - (byte) 0, - (byte) 5, - (byte) 0, - (byte) 5, - (byte) 0, - (byte) 5, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x42, 0x208, payload); - MsgDops msg = new MsgDops(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgDopsTest.test1"); + byte[] payload = new byte[] {(byte)100,(byte)0,(byte)0,(byte)0,(byte)2,(byte)0,(byte)6,(byte)0,(byte)5,(byte)0,(byte)5,(byte)0,(byte)5,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x42, 0x208, payload ); + MsgDops msg = new MsgDops( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -62,8 +50,7 @@ public void test1() throws Throwable { } value = msg.gdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gdop + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.gdop + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -71,8 +58,7 @@ public void test1() throws Throwable { } value = msg.hdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hdop + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.hdop + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -80,8 +66,7 @@ public void test1() throws Throwable { } value = msg.pdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pdop + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.pdop + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -89,8 +74,7 @@ public void test1() throws Throwable { } value = msg.tdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tdop + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.tdop + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -98,8 +82,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 100 + "'", value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -107,8 +90,7 @@ public void test1() throws Throwable { } value = msg.vdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vdop + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.vdop + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; diff --git a/java/test/auto_check_sbp_navigation_MsgGPSTimeDepATest.java b/java/test/auto_check_sbp_navigation_MsgGPSTimeDepATest.java index 4fc292d5e..2af8ee8f5 100644 --- a/java/test/auto_check_sbp_navigation_MsgGPSTimeDepATest.java +++ b/java/test/auto_check_sbp_navigation_MsgGPSTimeDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSTimeDepA.yaml by generate.py. Do not modify by -// hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSTimeDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgGPSTimeDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgGPSTimeDepATest { @@ -30,29 +34,15 @@ public class auto_check_sbp_navigation_MsgGPSTimeDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 251, - (byte) 6, - (byte) 120, - (byte) 46, - (byte) 39, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x100, payload); - MsgGPSTimeDepA msg = new MsgGPSTimeDepA(sbp); + byte[] payload = new byte[] {(byte)251,(byte)6,(byte)120,(byte)46,(byte)39,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x100, payload ); + MsgGPSTimeDepA msg = new MsgGPSTimeDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -60,9 +50,7 @@ public void test1() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -70,9 +58,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567800 + "'", - value.equals(BigInteger.valueOf(2567800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567800 + "'", value.equals(BigInteger.valueOf( 2567800L ) ) ); } else { value = value.longValue(); expected = 2567800L; @@ -80,8 +66,7 @@ public void test1() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1787 + "'", value.equals(BigInteger.valueOf(1787L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1787 + "'", value.equals(BigInteger.valueOf( 1787L ) ) ); } else { value = value.longValue(); expected = 1787L; @@ -95,29 +80,15 @@ public void test1() throws Throwable { public void test2() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeDepATest.test2"); - byte[] payload = - new byte[] { - (byte) 251, - (byte) 6, - (byte) 220, - (byte) 46, - (byte) 39, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x100, payload); - MsgGPSTimeDepA msg = new MsgGPSTimeDepA(sbp); + byte[] payload = new byte[] {(byte)251,(byte)6,(byte)220,(byte)46,(byte)39,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x100, payload ); + MsgGPSTimeDepA msg = new MsgGPSTimeDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -125,9 +96,7 @@ public void test2() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -135,9 +104,7 @@ public void test2() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567900 + "'", - value.equals(BigInteger.valueOf(2567900L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567900 + "'", value.equals(BigInteger.valueOf( 2567900L ) ) ); } else { value = value.longValue(); expected = 2567900L; @@ -145,8 +112,7 @@ public void test2() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1787 + "'", value.equals(BigInteger.valueOf(1787L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1787 + "'", value.equals(BigInteger.valueOf( 1787L ) ) ); } else { value = value.longValue(); expected = 1787L; @@ -160,29 +126,15 @@ public void test2() throws Throwable { public void test3() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeDepATest.test3"); - byte[] payload = - new byte[] { - (byte) 251, - (byte) 6, - (byte) 64, - (byte) 47, - (byte) 39, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x100, payload); - MsgGPSTimeDepA msg = new MsgGPSTimeDepA(sbp); + byte[] payload = new byte[] {(byte)251,(byte)6,(byte)64,(byte)47,(byte)39,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x100, payload ); + MsgGPSTimeDepA msg = new MsgGPSTimeDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -190,9 +142,7 @@ public void test3() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -200,9 +150,7 @@ public void test3() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2568000 + "'", - value.equals(BigInteger.valueOf(2568000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2568000 + "'", value.equals(BigInteger.valueOf( 2568000L ) ) ); } else { value = value.longValue(); expected = 2568000L; @@ -210,8 +158,7 @@ public void test3() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1787 + "'", value.equals(BigInteger.valueOf(1787L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1787 + "'", value.equals(BigInteger.valueOf( 1787L ) ) ); } else { value = value.longValue(); expected = 1787L; @@ -225,29 +172,15 @@ public void test3() throws Throwable { public void test4() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeDepATest.test4"); - byte[] payload = - new byte[] { - (byte) 251, - (byte) 6, - (byte) 164, - (byte) 47, - (byte) 39, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x100, payload); - MsgGPSTimeDepA msg = new MsgGPSTimeDepA(sbp); + byte[] payload = new byte[] {(byte)251,(byte)6,(byte)164,(byte)47,(byte)39,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x100, payload ); + MsgGPSTimeDepA msg = new MsgGPSTimeDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -255,9 +188,7 @@ public void test4() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -265,9 +196,7 @@ public void test4() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2568100 + "'", - value.equals(BigInteger.valueOf(2568100L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2568100 + "'", value.equals(BigInteger.valueOf( 2568100L ) ) ); } else { value = value.longValue(); expected = 2568100L; @@ -275,8 +204,7 @@ public void test4() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1787 + "'", value.equals(BigInteger.valueOf(1787L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1787 + "'", value.equals(BigInteger.valueOf( 1787L ) ) ); } else { value = value.longValue(); expected = 1787L; @@ -290,29 +218,15 @@ public void test4() throws Throwable { public void test5() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeDepATest.test5"); - byte[] payload = - new byte[] { - (byte) 251, - (byte) 6, - (byte) 8, - (byte) 48, - (byte) 39, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x100, payload); - MsgGPSTimeDepA msg = new MsgGPSTimeDepA(sbp); + byte[] payload = new byte[] {(byte)251,(byte)6,(byte)8,(byte)48,(byte)39,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x100, payload ); + MsgGPSTimeDepA msg = new MsgGPSTimeDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -320,9 +234,7 @@ public void test5() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -330,9 +242,7 @@ public void test5() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2568200 + "'", - value.equals(BigInteger.valueOf(2568200L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2568200 + "'", value.equals(BigInteger.valueOf( 2568200L ) ) ); } else { value = value.longValue(); expected = 2568200L; @@ -340,8 +250,7 @@ public void test5() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1787 + "'", value.equals(BigInteger.valueOf(1787L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1787 + "'", value.equals(BigInteger.valueOf( 1787L ) ) ); } else { value = value.longValue(); expected = 1787L; @@ -355,29 +264,15 @@ public void test5() throws Throwable { public void test6() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeDepATest.test6"); - byte[] payload = - new byte[] { - (byte) 46, - (byte) 7, - (byte) 212, - (byte) 157, - (byte) 67, - (byte) 24, - (byte) 111, - (byte) 147, - (byte) 252, - (byte) 255, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x100, payload); - MsgGPSTimeDepA msg = new MsgGPSTimeDepA(sbp); + byte[] payload = new byte[] {(byte)46,(byte)7,(byte)212,(byte)157,(byte)67,(byte)24,(byte)111,(byte)147,(byte)252,(byte)255,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x100, payload ); + MsgGPSTimeDepA msg = new MsgGPSTimeDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -385,9 +280,7 @@ public void test6() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + -224401 + "'", - value.equals(BigInteger.valueOf(-224401L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + -224401 + "'", value.equals(BigInteger.valueOf( -224401L ) ) ); } else { value = value.longValue(); expected = -224401L; @@ -395,9 +288,7 @@ public void test6() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084500 + "'", - value.equals(BigInteger.valueOf(407084500L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084500 + "'", value.equals(BigInteger.valueOf( 407084500L ) ) ); } else { value = value.longValue(); expected = 407084500L; @@ -405,8 +296,7 @@ public void test6() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1838 + "'", value.equals(BigInteger.valueOf(1838L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1838 + "'", value.equals(BigInteger.valueOf( 1838L ) ) ); } else { value = value.longValue(); expected = 1838L; @@ -420,29 +310,15 @@ public void test6() throws Throwable { public void test7() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeDepATest.test7"); - byte[] payload = - new byte[] { - (byte) 46, - (byte) 7, - (byte) 56, - (byte) 158, - (byte) 67, - (byte) 24, - (byte) 109, - (byte) 103, - (byte) 3, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x100, payload); - MsgGPSTimeDepA msg = new MsgGPSTimeDepA(sbp); + byte[] payload = new byte[] {(byte)46,(byte)7,(byte)56,(byte)158,(byte)67,(byte)24,(byte)109,(byte)103,(byte)3,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x100, payload ); + MsgGPSTimeDepA msg = new MsgGPSTimeDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -450,9 +326,7 @@ public void test7() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 223085 + "'", - value.equals(BigInteger.valueOf(223085L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 223085 + "'", value.equals(BigInteger.valueOf( 223085L ) ) ); } else { value = value.longValue(); expected = 223085L; @@ -460,9 +334,7 @@ public void test7() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084600 + "'", - value.equals(BigInteger.valueOf(407084600L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084600 + "'", value.equals(BigInteger.valueOf( 407084600L ) ) ); } else { value = value.longValue(); expected = 407084600L; @@ -470,8 +342,7 @@ public void test7() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1838 + "'", value.equals(BigInteger.valueOf(1838L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1838 + "'", value.equals(BigInteger.valueOf( 1838L ) ) ); } else { value = value.longValue(); expected = 1838L; @@ -485,29 +356,15 @@ public void test7() throws Throwable { public void test8() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeDepATest.test8"); - byte[] payload = - new byte[] { - (byte) 46, - (byte) 7, - (byte) 156, - (byte) 158, - (byte) 67, - (byte) 24, - (byte) 233, - (byte) 152, - (byte) 252, - (byte) 255, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x100, payload); - MsgGPSTimeDepA msg = new MsgGPSTimeDepA(sbp); + byte[] payload = new byte[] {(byte)46,(byte)7,(byte)156,(byte)158,(byte)67,(byte)24,(byte)233,(byte)152,(byte)252,(byte)255,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x100, payload ); + MsgGPSTimeDepA msg = new MsgGPSTimeDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -515,9 +372,7 @@ public void test8() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + -222999 + "'", - value.equals(BigInteger.valueOf(-222999L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + -222999 + "'", value.equals(BigInteger.valueOf( -222999L ) ) ); } else { value = value.longValue(); expected = -222999L; @@ -525,9 +380,7 @@ public void test8() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084700 + "'", - value.equals(BigInteger.valueOf(407084700L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084700 + "'", value.equals(BigInteger.valueOf( 407084700L ) ) ); } else { value = value.longValue(); expected = 407084700L; @@ -535,8 +388,7 @@ public void test8() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1838 + "'", value.equals(BigInteger.valueOf(1838L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1838 + "'", value.equals(BigInteger.valueOf( 1838L ) ) ); } else { value = value.longValue(); expected = 1838L; @@ -550,29 +402,15 @@ public void test8() throws Throwable { public void test9() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeDepATest.test9"); - byte[] payload = - new byte[] { - (byte) 46, - (byte) 7, - (byte) 0, - (byte) 159, - (byte) 67, - (byte) 24, - (byte) 240, - (byte) 154, - (byte) 3, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x100, payload); - MsgGPSTimeDepA msg = new MsgGPSTimeDepA(sbp); + byte[] payload = new byte[] {(byte)46,(byte)7,(byte)0,(byte)159,(byte)67,(byte)24,(byte)240,(byte)154,(byte)3,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x100, payload ); + MsgGPSTimeDepA msg = new MsgGPSTimeDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -580,9 +418,7 @@ public void test9() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 236272 + "'", - value.equals(BigInteger.valueOf(236272L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 236272 + "'", value.equals(BigInteger.valueOf( 236272L ) ) ); } else { value = value.longValue(); expected = 236272L; @@ -590,9 +426,7 @@ public void test9() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084800 + "'", - value.equals(BigInteger.valueOf(407084800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084800 + "'", value.equals(BigInteger.valueOf( 407084800L ) ) ); } else { value = value.longValue(); expected = 407084800L; @@ -600,8 +434,7 @@ public void test9() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1838 + "'", value.equals(BigInteger.valueOf(1838L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1838 + "'", value.equals(BigInteger.valueOf( 1838L ) ) ); } else { value = value.longValue(); expected = 1838L; @@ -615,29 +448,15 @@ public void test9() throws Throwable { public void test10() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeDepATest.test10"); - byte[] payload = - new byte[] { - (byte) 46, - (byte) 7, - (byte) 100, - (byte) 159, - (byte) 67, - (byte) 24, - (byte) 144, - (byte) 101, - (byte) 252, - (byte) 255, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x100, payload); - MsgGPSTimeDepA msg = new MsgGPSTimeDepA(sbp); + byte[] payload = new byte[] {(byte)46,(byte)7,(byte)100,(byte)159,(byte)67,(byte)24,(byte)144,(byte)101,(byte)252,(byte)255,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x100, payload ); + MsgGPSTimeDepA msg = new MsgGPSTimeDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -645,9 +464,7 @@ public void test10() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + -236144 + "'", - value.equals(BigInteger.valueOf(-236144L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + -236144 + "'", value.equals(BigInteger.valueOf( -236144L ) ) ); } else { value = value.longValue(); expected = -236144L; @@ -655,9 +472,7 @@ public void test10() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084900 + "'", - value.equals(BigInteger.valueOf(407084900L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084900 + "'", value.equals(BigInteger.valueOf( 407084900L ) ) ); } else { value = value.longValue(); expected = 407084900L; @@ -665,8 +480,7 @@ public void test10() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1838 + "'", value.equals(BigInteger.valueOf(1838L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1838 + "'", value.equals(BigInteger.valueOf( 1838L ) ) ); } else { value = value.longValue(); expected = 1838L; @@ -680,29 +494,15 @@ public void test10() throws Throwable { public void test11() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeDepATest.test11"); - byte[] payload = - new byte[] { - (byte) 46, - (byte) 7, - (byte) 46, - (byte) 162, - (byte) 68, - (byte) 24, - (byte) 205, - (byte) 230, - (byte) 250, - (byte) 255, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x100, payload); - MsgGPSTimeDepA msg = new MsgGPSTimeDepA(sbp); + byte[] payload = new byte[] {(byte)46,(byte)7,(byte)46,(byte)162,(byte)68,(byte)24,(byte)205,(byte)230,(byte)250,(byte)255,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x100, payload ); + MsgGPSTimeDepA msg = new MsgGPSTimeDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -710,9 +510,7 @@ public void test11() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + -334131 + "'", - value.equals(BigInteger.valueOf(-334131L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + -334131 + "'", value.equals(BigInteger.valueOf( -334131L ) ) ); } else { value = value.longValue(); expected = -334131L; @@ -720,9 +518,7 @@ public void test11() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407151150 + "'", - value.equals(BigInteger.valueOf(407151150L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407151150 + "'", value.equals(BigInteger.valueOf( 407151150L ) ) ); } else { value = value.longValue(); expected = 407151150L; @@ -730,8 +526,7 @@ public void test11() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1838 + "'", value.equals(BigInteger.valueOf(1838L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1838 + "'", value.equals(BigInteger.valueOf( 1838L ) ) ); } else { value = value.longValue(); expected = 1838L; diff --git a/java/test/auto_check_sbp_navigation_MsgGPSTimeGNSSTest.java b/java/test/auto_check_sbp_navigation_MsgGPSTimeGNSSTest.java index 85c75ea84..3ed1c4c36 100644 --- a/java/test/auto_check_sbp_navigation_MsgGPSTimeGNSSTest.java +++ b/java/test/auto_check_sbp_navigation_MsgGPSTimeGNSSTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSTimeGNSS.yaml by generate.py. Do not modify by -// hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSTimeGNSS.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgGPSTimeGnss; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgGPSTimeGNSSTest { @@ -30,29 +34,15 @@ public class auto_check_sbp_navigation_MsgGPSTimeGNSSTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeGNSSTest.test1"); - byte[] payload = - new byte[] { - (byte) 128, - (byte) 7, - (byte) 40, - (byte) 244, - (byte) 122, - (byte) 19, - (byte) 244, - (byte) 139, - (byte) 2, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x104, payload); - MsgGPSTimeGnss msg = new MsgGPSTimeGnss(sbp); + byte[] payload = new byte[] {(byte)128,(byte)7,(byte)40,(byte)244,(byte)122,(byte)19,(byte)244,(byte)139,(byte)2,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x104, payload ); + MsgGPSTimeGnss msg = new MsgGPSTimeGnss( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -60,9 +50,7 @@ public void test1() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 166900 + "'", - value.equals(BigInteger.valueOf(166900L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 166900 + "'", value.equals(BigInteger.valueOf( 166900L ) ) ); } else { value = value.longValue(); expected = 166900L; @@ -70,9 +58,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326825000 + "'", - value.equals(BigInteger.valueOf(326825000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326825000 + "'", value.equals(BigInteger.valueOf( 326825000L ) ) ); } else { value = value.longValue(); expected = 326825000L; @@ -80,8 +66,7 @@ public void test1() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf(1920L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf( 1920L ) ) ); } else { value = value.longValue(); expected = 1920L; @@ -95,29 +80,15 @@ public void test1() throws Throwable { public void test2() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeGNSSTest.test2"); - byte[] payload = - new byte[] { - (byte) 128, - (byte) 7, - (byte) 28, - (byte) 246, - (byte) 122, - (byte) 19, - (byte) 126, - (byte) 234, - (byte) 3, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x104, payload); - MsgGPSTimeGnss msg = new MsgGPSTimeGnss(sbp); + byte[] payload = new byte[] {(byte)128,(byte)7,(byte)28,(byte)246,(byte)122,(byte)19,(byte)126,(byte)234,(byte)3,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x104, payload ); + MsgGPSTimeGnss msg = new MsgGPSTimeGnss( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -125,9 +96,7 @@ public void test2() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 256638 + "'", - value.equals(BigInteger.valueOf(256638L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 256638 + "'", value.equals(BigInteger.valueOf( 256638L ) ) ); } else { value = value.longValue(); expected = 256638L; @@ -135,9 +104,7 @@ public void test2() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326825500 + "'", - value.equals(BigInteger.valueOf(326825500L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326825500 + "'", value.equals(BigInteger.valueOf( 326825500L ) ) ); } else { value = value.longValue(); expected = 326825500L; @@ -145,8 +112,7 @@ public void test2() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf(1920L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf( 1920L ) ) ); } else { value = value.longValue(); expected = 1920L; @@ -160,29 +126,15 @@ public void test2() throws Throwable { public void test3() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeGNSSTest.test3"); - byte[] payload = - new byte[] { - (byte) 128, - (byte) 7, - (byte) 16, - (byte) 248, - (byte) 122, - (byte) 19, - (byte) 129, - (byte) 12, - (byte) 4, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x104, payload); - MsgGPSTimeGnss msg = new MsgGPSTimeGnss(sbp); + byte[] payload = new byte[] {(byte)128,(byte)7,(byte)16,(byte)248,(byte)122,(byte)19,(byte)129,(byte)12,(byte)4,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x104, payload ); + MsgGPSTimeGnss msg = new MsgGPSTimeGnss( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -190,9 +142,7 @@ public void test3() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 265345 + "'", - value.equals(BigInteger.valueOf(265345L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 265345 + "'", value.equals(BigInteger.valueOf( 265345L ) ) ); } else { value = value.longValue(); expected = 265345L; @@ -200,9 +150,7 @@ public void test3() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326826000 + "'", - value.equals(BigInteger.valueOf(326826000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326826000 + "'", value.equals(BigInteger.valueOf( 326826000L ) ) ); } else { value = value.longValue(); expected = 326826000L; @@ -210,8 +158,7 @@ public void test3() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf(1920L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf( 1920L ) ) ); } else { value = value.longValue(); expected = 1920L; @@ -225,29 +172,15 @@ public void test3() throws Throwable { public void test4() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeGNSSTest.test4"); - byte[] payload = - new byte[] { - (byte) 128, - (byte) 7, - (byte) 4, - (byte) 250, - (byte) 122, - (byte) 19, - (byte) 137, - (byte) 204, - (byte) 4, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x104, payload); - MsgGPSTimeGnss msg = new MsgGPSTimeGnss(sbp); + byte[] payload = new byte[] {(byte)128,(byte)7,(byte)4,(byte)250,(byte)122,(byte)19,(byte)137,(byte)204,(byte)4,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x104, payload ); + MsgGPSTimeGnss msg = new MsgGPSTimeGnss( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -255,9 +188,7 @@ public void test4() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 314505 + "'", - value.equals(BigInteger.valueOf(314505L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 314505 + "'", value.equals(BigInteger.valueOf( 314505L ) ) ); } else { value = value.longValue(); expected = 314505L; @@ -265,9 +196,7 @@ public void test4() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326826500 + "'", - value.equals(BigInteger.valueOf(326826500L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326826500 + "'", value.equals(BigInteger.valueOf( 326826500L ) ) ); } else { value = value.longValue(); expected = 326826500L; @@ -275,8 +204,7 @@ public void test4() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf(1920L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf( 1920L ) ) ); } else { value = value.longValue(); expected = 1920L; @@ -290,29 +218,15 @@ public void test4() throws Throwable { public void test5() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeGNSSTest.test5"); - byte[] payload = - new byte[] { - (byte) 128, - (byte) 7, - (byte) 248, - (byte) 251, - (byte) 122, - (byte) 19, - (byte) 181, - (byte) 137, - (byte) 5, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x104, payload); - MsgGPSTimeGnss msg = new MsgGPSTimeGnss(sbp); + byte[] payload = new byte[] {(byte)128,(byte)7,(byte)248,(byte)251,(byte)122,(byte)19,(byte)181,(byte)137,(byte)5,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x104, payload ); + MsgGPSTimeGnss msg = new MsgGPSTimeGnss( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -320,9 +234,7 @@ public void test5() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 362933 + "'", - value.equals(BigInteger.valueOf(362933L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 362933 + "'", value.equals(BigInteger.valueOf( 362933L ) ) ); } else { value = value.longValue(); expected = 362933L; @@ -330,9 +242,7 @@ public void test5() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326827000 + "'", - value.equals(BigInteger.valueOf(326827000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326827000 + "'", value.equals(BigInteger.valueOf( 326827000L ) ) ); } else { value = value.longValue(); expected = 326827000L; @@ -340,8 +250,7 @@ public void test5() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf(1920L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf( 1920L ) ) ); } else { value = value.longValue(); expected = 1920L; diff --git a/java/test/auto_check_sbp_navigation_MsgGPSTimeTest.java b/java/test/auto_check_sbp_navigation_MsgGPSTimeTest.java index 00c6e1303..ed5e1db53 100644 --- a/java/test/auto_check_sbp_navigation_MsgGPSTimeTest.java +++ b/java/test/auto_check_sbp_navigation_MsgGPSTimeTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSTime.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgGPSTime.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgGPSTime; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgGPSTimeTest { @@ -27,30 +32,17 @@ public class auto_check_sbp_navigation_MsgGPSTimeTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeTest.test1"); - byte[] payload = - new byte[] { - (byte) 128, - (byte) 7, - (byte) 40, - (byte) 244, - (byte) 122, - (byte) 19, - (byte) 244, - (byte) 139, - (byte) 2, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x102, payload); - MsgGPSTime msg = new MsgGPSTime(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeTest.test1"); + byte[] payload = new byte[] {(byte)128,(byte)7,(byte)40,(byte)244,(byte)122,(byte)19,(byte)244,(byte)139,(byte)2,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x102, payload ); + MsgGPSTime msg = new MsgGPSTime( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -58,9 +50,7 @@ public void test1() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 166900 + "'", - value.equals(BigInteger.valueOf(166900L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 166900 + "'", value.equals(BigInteger.valueOf( 166900L ) ) ); } else { value = value.longValue(); expected = 166900L; @@ -68,9 +58,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326825000 + "'", - value.equals(BigInteger.valueOf(326825000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326825000 + "'", value.equals(BigInteger.valueOf( 326825000L ) ) ); } else { value = value.longValue(); expected = 326825000L; @@ -78,8 +66,7 @@ public void test1() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf(1920L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf( 1920L ) ) ); } else { value = value.longValue(); expected = 1920L; @@ -91,30 +78,17 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeTest.test2"); - byte[] payload = - new byte[] { - (byte) 128, - (byte) 7, - (byte) 28, - (byte) 246, - (byte) 122, - (byte) 19, - (byte) 126, - (byte) 234, - (byte) 3, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x102, payload); - MsgGPSTime msg = new MsgGPSTime(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeTest.test2"); + byte[] payload = new byte[] {(byte)128,(byte)7,(byte)28,(byte)246,(byte)122,(byte)19,(byte)126,(byte)234,(byte)3,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x102, payload ); + MsgGPSTime msg = new MsgGPSTime( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -122,9 +96,7 @@ public void test2() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 256638 + "'", - value.equals(BigInteger.valueOf(256638L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 256638 + "'", value.equals(BigInteger.valueOf( 256638L ) ) ); } else { value = value.longValue(); expected = 256638L; @@ -132,9 +104,7 @@ public void test2() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326825500 + "'", - value.equals(BigInteger.valueOf(326825500L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326825500 + "'", value.equals(BigInteger.valueOf( 326825500L ) ) ); } else { value = value.longValue(); expected = 326825500L; @@ -142,8 +112,7 @@ public void test2() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf(1920L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf( 1920L ) ) ); } else { value = value.longValue(); expected = 1920L; @@ -155,30 +124,17 @@ public void test2() throws Throwable { @Test public void test3() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeTest.test3"); - byte[] payload = - new byte[] { - (byte) 128, - (byte) 7, - (byte) 16, - (byte) 248, - (byte) 122, - (byte) 19, - (byte) 129, - (byte) 12, - (byte) 4, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x102, payload); - MsgGPSTime msg = new MsgGPSTime(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeTest.test3"); + byte[] payload = new byte[] {(byte)128,(byte)7,(byte)16,(byte)248,(byte)122,(byte)19,(byte)129,(byte)12,(byte)4,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x102, payload ); + MsgGPSTime msg = new MsgGPSTime( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -186,9 +142,7 @@ public void test3() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 265345 + "'", - value.equals(BigInteger.valueOf(265345L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 265345 + "'", value.equals(BigInteger.valueOf( 265345L ) ) ); } else { value = value.longValue(); expected = 265345L; @@ -196,9 +150,7 @@ public void test3() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326826000 + "'", - value.equals(BigInteger.valueOf(326826000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326826000 + "'", value.equals(BigInteger.valueOf( 326826000L ) ) ); } else { value = value.longValue(); expected = 326826000L; @@ -206,8 +158,7 @@ public void test3() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf(1920L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf( 1920L ) ) ); } else { value = value.longValue(); expected = 1920L; @@ -219,30 +170,17 @@ public void test3() throws Throwable { @Test public void test4() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeTest.test4"); - byte[] payload = - new byte[] { - (byte) 128, - (byte) 7, - (byte) 4, - (byte) 250, - (byte) 122, - (byte) 19, - (byte) 137, - (byte) 204, - (byte) 4, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x102, payload); - MsgGPSTime msg = new MsgGPSTime(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeTest.test4"); + byte[] payload = new byte[] {(byte)128,(byte)7,(byte)4,(byte)250,(byte)122,(byte)19,(byte)137,(byte)204,(byte)4,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x102, payload ); + MsgGPSTime msg = new MsgGPSTime( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -250,9 +188,7 @@ public void test4() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 314505 + "'", - value.equals(BigInteger.valueOf(314505L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 314505 + "'", value.equals(BigInteger.valueOf( 314505L ) ) ); } else { value = value.longValue(); expected = 314505L; @@ -260,9 +196,7 @@ public void test4() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326826500 + "'", - value.equals(BigInteger.valueOf(326826500L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326826500 + "'", value.equals(BigInteger.valueOf( 326826500L ) ) ); } else { value = value.longValue(); expected = 326826500L; @@ -270,8 +204,7 @@ public void test4() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf(1920L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf( 1920L ) ) ); } else { value = value.longValue(); expected = 1920L; @@ -283,30 +216,17 @@ public void test4() throws Throwable { @Test public void test5() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeTest.test5"); - byte[] payload = - new byte[] { - (byte) 128, - (byte) 7, - (byte) 248, - (byte) 251, - (byte) 122, - (byte) 19, - (byte) 181, - (byte) 137, - (byte) 5, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x102, payload); - MsgGPSTime msg = new MsgGPSTime(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgGPSTimeTest.test5"); + byte[] payload = new byte[] {(byte)128,(byte)7,(byte)248,(byte)251,(byte)122,(byte)19,(byte)181,(byte)137,(byte)5,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x102, payload ); + MsgGPSTime msg = new MsgGPSTime( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -314,9 +234,7 @@ public void test5() throws Throwable { } value = msg.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ns_residual + "' != '" + 362933 + "'", - value.equals(BigInteger.valueOf(362933L))); + org.junit.Assert.assertTrue("'" + msg.ns_residual + "' != '" + 362933 + "'", value.equals(BigInteger.valueOf( 362933L ) ) ); } else { value = value.longValue(); expected = 362933L; @@ -324,9 +242,7 @@ public void test5() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326827000 + "'", - value.equals(BigInteger.valueOf(326827000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326827000 + "'", value.equals(BigInteger.valueOf( 326827000L ) ) ); } else { value = value.longValue(); expected = 326827000L; @@ -334,8 +250,7 @@ public void test5() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf(1920L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 1920 + "'", value.equals(BigInteger.valueOf( 1920L ) ) ); } else { value = value.longValue(); expected = 1920L; diff --git a/java/test/auto_check_sbp_navigation_MsgPosECEFCovGNSSTest.java b/java/test/auto_check_sbp_navigation_MsgPosECEFCovGNSSTest.java index 3186fca2a..bf150d39a 100644 --- a/java/test/auto_check_sbp_navigation_MsgPosECEFCovGNSSTest.java +++ b/java/test/auto_check_sbp_navigation_MsgPosECEFCovGNSSTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosECEFCovGNSS.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosECEFCovGNSS.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgPosECEFCovGnss; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgPosECEFCovGNSSTest { @@ -30,65 +34,9 @@ public class auto_check_sbp_navigation_MsgPosECEFCovGNSSTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFCovGNSSTest.test1"); - byte[] payload = - new byte[] { - (byte) 24, - (byte) 229, - (byte) 233, - (byte) 29, - (byte) 52, - (byte) 254, - (byte) 158, - (byte) 218, - (byte) 42, - (byte) 142, - (byte) 68, - (byte) 193, - (byte) 69, - (byte) 162, - (byte) 89, - (byte) 91, - (byte) 34, - (byte) 68, - (byte) 80, - (byte) 193, - (byte) 131, - (byte) 21, - (byte) 176, - (byte) 129, - (byte) 239, - (byte) 174, - (byte) 77, - (byte) 65, - (byte) 158, - (byte) 232, - (byte) 30, - (byte) 60, - (byte) 218, - (byte) 221, - (byte) 20, - (byte) 60, - (byte) 129, - (byte) 136, - (byte) 198, - (byte) 187, - (byte) 205, - (byte) 120, - (byte) 166, - (byte) 60, - (byte) 5, - (byte) 166, - (byte) 35, - (byte) 188, - (byte) 122, - (byte) 177, - (byte) 115, - (byte) 60, - (byte) 18, - (byte) 4, - }; - SBPMessage sbp = new SBPMessage(0x1000, 0x234, payload); - MsgPosECEFCovGnss msg = new MsgPosECEFCovGnss(sbp); + byte[] payload = new byte[] {(byte)24,(byte)229,(byte)233,(byte)29,(byte)52,(byte)254,(byte)158,(byte)218,(byte)42,(byte)142,(byte)68,(byte)193,(byte)69,(byte)162,(byte)89,(byte)91,(byte)34,(byte)68,(byte)80,(byte)193,(byte)131,(byte)21,(byte)176,(byte)129,(byte)239,(byte)174,(byte)77,(byte)65,(byte)158,(byte)232,(byte)30,(byte)60,(byte)218,(byte)221,(byte)20,(byte)60,(byte)129,(byte)136,(byte)198,(byte)187,(byte)205,(byte)120,(byte)166,(byte)60,(byte)5,(byte)166,(byte)35,(byte)188,(byte)122,(byte)177,(byte)115,(byte)60,(byte)18,(byte)4, }; + SBPMessage sbp = new SBPMessage( 0x1000, 0x234, payload ); + MsgPosECEFCovGnss msg = new MsgPosECEFCovGnss( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -100,8 +48,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.cov_z_z, 1.48738566786050797e-02, DELTA); value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -109,8 +56,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 18 + "'", value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -118,9 +64,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 501867800 + "'", - value.equals(BigInteger.valueOf(501867800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 501867800 + "'", value.equals(BigInteger.valueOf( 501867800L ) ) ); } else { value = value.longValue(); expected = 501867800L; diff --git a/java/test/auto_check_sbp_navigation_MsgPosECEFCovTest.java b/java/test/auto_check_sbp_navigation_MsgPosECEFCovTest.java index 8b3c539e5..f21e572b1 100644 --- a/java/test/auto_check_sbp_navigation_MsgPosECEFCovTest.java +++ b/java/test/auto_check_sbp_navigation_MsgPosECEFCovTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosECEFCov.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosECEFCov.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgPosECEFCov; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgPosECEFCovTest { @@ -27,66 +32,11 @@ public class auto_check_sbp_navigation_MsgPosECEFCovTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFCovTest.test1"); - byte[] payload = - new byte[] { - (byte) 7, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 24, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 240, - (byte) 63, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 16, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 224, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 192, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 160, - (byte) 64, - (byte) 4, - (byte) 5, - }; - SBPMessage sbp = new SBPMessage(0x42, 0x214, payload); - MsgPosECEFCov msg = new MsgPosECEFCov(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFCovTest.test1"); + byte[] payload = new byte[] {(byte)7,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)24,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)240,(byte)63,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)16,(byte)64,(byte)0,(byte)0,(byte)0,(byte)65,(byte)0,(byte)0,(byte)224,(byte)64,(byte)0,(byte)0,(byte)0,(byte)64,(byte)0,(byte)0,(byte)192,(byte)64,(byte)0,(byte)0,(byte)0,(byte)65,(byte)0,(byte)0,(byte)160,(byte)64,(byte)4,(byte)5, }; + SBPMessage sbp = new SBPMessage( 0x42, 0x214, payload ); + MsgPosECEFCov msg = new MsgPosECEFCov( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -98,8 +48,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.cov_z_z, 5.00000000000000000e+00, DELTA); value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -107,8 +56,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -116,8 +64,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 7 + "'", value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; diff --git a/java/test/auto_check_sbp_navigation_MsgPosECEFDepATest.java b/java/test/auto_check_sbp_navigation_MsgPosECEFDepATest.java index 5cf64f116..4b4363fb2 100644 --- a/java/test/auto_check_sbp_navigation_MsgPosECEFDepATest.java +++ b/java/test/auto_check_sbp_navigation_MsgPosECEFDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosECEFDepA.yaml by generate.py. Do not modify by -// hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosECEFDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgPosECEFDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgPosECEFDepATest { @@ -30,23 +34,15 @@ public class auto_check_sbp_navigation_MsgPosECEFDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 20, (byte) 46, (byte) 39, (byte) 0, (byte) 195, (byte) 122, (byte) 175, - (byte) 75, (byte) 33, (byte) 154, (byte) 68, (byte) 193, (byte) 164, (byte) 14, - (byte) 230, (byte) 176, (byte) 231, (byte) 95, (byte) 80, (byte) 193, (byte) 78, - (byte) 220, (byte) 22, (byte) 253, (byte) 254, (byte) 105, (byte) 77, (byte) 65, - (byte) 0, (byte) 0, (byte) 9, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x200, payload); - MsgPosECEFDepA msg = new MsgPosECEFDepA(sbp); + byte[] payload = new byte[] {(byte)20,(byte)46,(byte)39,(byte)0,(byte)195,(byte)122,(byte)175,(byte)75,(byte)33,(byte)154,(byte)68,(byte)193,(byte)164,(byte)14,(byte)230,(byte)176,(byte)231,(byte)95,(byte)80,(byte)193,(byte)78,(byte)220,(byte)22,(byte)253,(byte)254,(byte)105,(byte)77,(byte)65,(byte)0,(byte)0,(byte)9,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x200, payload ); + MsgPosECEFDepA msg = new MsgPosECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -54,8 +50,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -63,8 +58,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -72,9 +66,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567700 + "'", - value.equals(BigInteger.valueOf(2567700L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567700 + "'", value.equals(BigInteger.valueOf( 2567700L ) ) ); } else { value = value.longValue(); expected = 2567700L; @@ -91,23 +83,15 @@ public void test1() throws Throwable { public void test2() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFDepATest.test2"); - byte[] payload = - new byte[] { - (byte) 20, (byte) 46, (byte) 39, (byte) 0, (byte) 212, (byte) 196, (byte) 12, - (byte) 42, (byte) 34, (byte) 154, (byte) 68, (byte) 193, (byte) 9, (byte) 113, - (byte) 112, (byte) 123, (byte) 231, (byte) 95, (byte) 80, (byte) 193, (byte) 54, - (byte) 97, (byte) 38, (byte) 192, (byte) 254, (byte) 105, (byte) 77, (byte) 65, - (byte) 0, (byte) 0, (byte) 9, (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x200, payload); - MsgPosECEFDepA msg = new MsgPosECEFDepA(sbp); + byte[] payload = new byte[] {(byte)20,(byte)46,(byte)39,(byte)0,(byte)212,(byte)196,(byte)12,(byte)42,(byte)34,(byte)154,(byte)68,(byte)193,(byte)9,(byte)113,(byte)112,(byte)123,(byte)231,(byte)95,(byte)80,(byte)193,(byte)54,(byte)97,(byte)38,(byte)192,(byte)254,(byte)105,(byte)77,(byte)65,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x200, payload ); + MsgPosECEFDepA msg = new MsgPosECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -115,8 +99,7 @@ public void test2() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -124,8 +107,7 @@ public void test2() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -133,9 +115,7 @@ public void test2() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567700 + "'", - value.equals(BigInteger.valueOf(2567700L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567700 + "'", value.equals(BigInteger.valueOf( 2567700L ) ) ); } else { value = value.longValue(); expected = 2567700L; @@ -152,23 +132,15 @@ public void test2() throws Throwable { public void test3() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFDepATest.test3"); - byte[] payload = - new byte[] { - (byte) 120, (byte) 46, (byte) 39, (byte) 0, (byte) 112, (byte) 97, (byte) 39, - (byte) 190, (byte) 34, (byte) 154, (byte) 68, (byte) 193, (byte) 230, (byte) 43, - (byte) 119, (byte) 115, (byte) 231, (byte) 95, (byte) 80, (byte) 193, (byte) 50, - (byte) 199, (byte) 76, (byte) 66, (byte) 254, (byte) 105, (byte) 77, (byte) 65, - (byte) 0, (byte) 0, (byte) 9, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x200, payload); - MsgPosECEFDepA msg = new MsgPosECEFDepA(sbp); + byte[] payload = new byte[] {(byte)120,(byte)46,(byte)39,(byte)0,(byte)112,(byte)97,(byte)39,(byte)190,(byte)34,(byte)154,(byte)68,(byte)193,(byte)230,(byte)43,(byte)119,(byte)115,(byte)231,(byte)95,(byte)80,(byte)193,(byte)50,(byte)199,(byte)76,(byte)66,(byte)254,(byte)105,(byte)77,(byte)65,(byte)0,(byte)0,(byte)9,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x200, payload ); + MsgPosECEFDepA msg = new MsgPosECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -176,8 +148,7 @@ public void test3() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -185,8 +156,7 @@ public void test3() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -194,9 +164,7 @@ public void test3() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567800 + "'", - value.equals(BigInteger.valueOf(2567800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567800 + "'", value.equals(BigInteger.valueOf( 2567800L ) ) ); } else { value = value.longValue(); expected = 2567800L; @@ -213,50 +181,15 @@ public void test3() throws Throwable { public void test4() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFDepATest.test4"); - byte[] payload = - new byte[] { - (byte) 120, - (byte) 46, - (byte) 39, - (byte) 0, - (byte) 194, - (byte) 82, - (byte) 121, - (byte) 4, - (byte) 34, - (byte) 154, - (byte) 68, - (byte) 193, - (byte) 223, - (byte) 186, - (byte) 1, - (byte) 140, - (byte) 231, - (byte) 95, - (byte) 80, - (byte) 193, - (byte) 176, - (byte) 152, - (byte) 147, - (byte) 181, - (byte) 254, - (byte) 105, - (byte) 77, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x200, payload); - MsgPosECEFDepA msg = new MsgPosECEFDepA(sbp); + byte[] payload = new byte[] {(byte)120,(byte)46,(byte)39,(byte)0,(byte)194,(byte)82,(byte)121,(byte)4,(byte)34,(byte)154,(byte)68,(byte)193,(byte)223,(byte)186,(byte)1,(byte)140,(byte)231,(byte)95,(byte)80,(byte)193,(byte)176,(byte)152,(byte)147,(byte)181,(byte)254,(byte)105,(byte)77,(byte)65,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x200, payload ); + MsgPosECEFDepA msg = new MsgPosECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -264,8 +197,7 @@ public void test4() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -273,8 +205,7 @@ public void test4() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -282,9 +213,7 @@ public void test4() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567800 + "'", - value.equals(BigInteger.valueOf(2567800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567800 + "'", value.equals(BigInteger.valueOf( 2567800L ) ) ); } else { value = value.longValue(); expected = 2567800L; @@ -301,50 +230,15 @@ public void test4() throws Throwable { public void test5() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFDepATest.test5"); - byte[] payload = - new byte[] { - (byte) 220, - (byte) 46, - (byte) 39, - (byte) 0, - (byte) 216, - (byte) 41, - (byte) 227, - (byte) 254, - (byte) 33, - (byte) 154, - (byte) 68, - (byte) 193, - (byte) 9, - (byte) 151, - (byte) 154, - (byte) 124, - (byte) 231, - (byte) 95, - (byte) 80, - (byte) 193, - (byte) 1, - (byte) 183, - (byte) 214, - (byte) 139, - (byte) 255, - (byte) 105, - (byte) 77, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x200, payload); - MsgPosECEFDepA msg = new MsgPosECEFDepA(sbp); + byte[] payload = new byte[] {(byte)220,(byte)46,(byte)39,(byte)0,(byte)216,(byte)41,(byte)227,(byte)254,(byte)33,(byte)154,(byte)68,(byte)193,(byte)9,(byte)151,(byte)154,(byte)124,(byte)231,(byte)95,(byte)80,(byte)193,(byte)1,(byte)183,(byte)214,(byte)139,(byte)255,(byte)105,(byte)77,(byte)65,(byte)0,(byte)0,(byte)9,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x200, payload ); + MsgPosECEFDepA msg = new MsgPosECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -352,8 +246,7 @@ public void test5() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -361,8 +254,7 @@ public void test5() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -370,9 +262,7 @@ public void test5() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567900 + "'", - value.equals(BigInteger.valueOf(2567900L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567900 + "'", value.equals(BigInteger.valueOf( 2567900L ) ) ); } else { value = value.longValue(); expected = 2567900L; @@ -389,50 +279,15 @@ public void test5() throws Throwable { public void test6() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFDepATest.test6"); - byte[] payload = - new byte[] { - (byte) 212, - (byte) 157, - (byte) 67, - (byte) 24, - (byte) 153, - (byte) 222, - (byte) 105, - (byte) 1, - (byte) 252, - (byte) 161, - (byte) 68, - (byte) 193, - (byte) 254, - (byte) 247, - (byte) 52, - (byte) 112, - (byte) 74, - (byte) 67, - (byte) 80, - (byte) 193, - (byte) 164, - (byte) 207, - (byte) 47, - (byte) 146, - (byte) 44, - (byte) 163, - (byte) 77, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 8, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x200, payload); - MsgPosECEFDepA msg = new MsgPosECEFDepA(sbp); + byte[] payload = new byte[] {(byte)212,(byte)157,(byte)67,(byte)24,(byte)153,(byte)222,(byte)105,(byte)1,(byte)252,(byte)161,(byte)68,(byte)193,(byte)254,(byte)247,(byte)52,(byte)112,(byte)74,(byte)67,(byte)80,(byte)193,(byte)164,(byte)207,(byte)47,(byte)146,(byte)44,(byte)163,(byte)77,(byte)65,(byte)0,(byte)0,(byte)8,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x200, payload ); + MsgPosECEFDepA msg = new MsgPosECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -440,8 +295,7 @@ public void test6() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -449,8 +303,7 @@ public void test6() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -458,9 +311,7 @@ public void test6() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084500 + "'", - value.equals(BigInteger.valueOf(407084500L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084500 + "'", value.equals(BigInteger.valueOf( 407084500L ) ) ); } else { value = value.longValue(); expected = 407084500L; @@ -477,50 +328,15 @@ public void test6() throws Throwable { public void test7() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFDepATest.test7"); - byte[] payload = - new byte[] { - (byte) 56, - (byte) 158, - (byte) 67, - (byte) 24, - (byte) 215, - (byte) 184, - (byte) 223, - (byte) 246, - (byte) 251, - (byte) 161, - (byte) 68, - (byte) 193, - (byte) 36, - (byte) 126, - (byte) 17, - (byte) 39, - (byte) 74, - (byte) 67, - (byte) 80, - (byte) 193, - (byte) 19, - (byte) 179, - (byte) 70, - (byte) 80, - (byte) 44, - (byte) 163, - (byte) 77, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 8, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x200, payload); - MsgPosECEFDepA msg = new MsgPosECEFDepA(sbp); + byte[] payload = new byte[] {(byte)56,(byte)158,(byte)67,(byte)24,(byte)215,(byte)184,(byte)223,(byte)246,(byte)251,(byte)161,(byte)68,(byte)193,(byte)36,(byte)126,(byte)17,(byte)39,(byte)74,(byte)67,(byte)80,(byte)193,(byte)19,(byte)179,(byte)70,(byte)80,(byte)44,(byte)163,(byte)77,(byte)65,(byte)0,(byte)0,(byte)8,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x200, payload ); + MsgPosECEFDepA msg = new MsgPosECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -528,8 +344,7 @@ public void test7() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -537,8 +352,7 @@ public void test7() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -546,9 +360,7 @@ public void test7() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084600 + "'", - value.equals(BigInteger.valueOf(407084600L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084600 + "'", value.equals(BigInteger.valueOf( 407084600L ) ) ); } else { value = value.longValue(); expected = 407084600L; @@ -565,50 +377,15 @@ public void test7() throws Throwable { public void test8() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFDepATest.test8"); - byte[] payload = - new byte[] { - (byte) 156, - (byte) 158, - (byte) 67, - (byte) 24, - (byte) 73, - (byte) 74, - (byte) 214, - (byte) 148, - (byte) 251, - (byte) 161, - (byte) 68, - (byte) 193, - (byte) 213, - (byte) 151, - (byte) 184, - (byte) 215, - (byte) 73, - (byte) 67, - (byte) 80, - (byte) 193, - (byte) 110, - (byte) 99, - (byte) 38, - (byte) 164, - (byte) 43, - (byte) 163, - (byte) 77, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 8, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x200, payload); - MsgPosECEFDepA msg = new MsgPosECEFDepA(sbp); + byte[] payload = new byte[] {(byte)156,(byte)158,(byte)67,(byte)24,(byte)73,(byte)74,(byte)214,(byte)148,(byte)251,(byte)161,(byte)68,(byte)193,(byte)213,(byte)151,(byte)184,(byte)215,(byte)73,(byte)67,(byte)80,(byte)193,(byte)110,(byte)99,(byte)38,(byte)164,(byte)43,(byte)163,(byte)77,(byte)65,(byte)0,(byte)0,(byte)8,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x200, payload ); + MsgPosECEFDepA msg = new MsgPosECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -616,8 +393,7 @@ public void test8() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -625,8 +401,7 @@ public void test8() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -634,9 +409,7 @@ public void test8() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084700 + "'", - value.equals(BigInteger.valueOf(407084700L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084700 + "'", value.equals(BigInteger.valueOf( 407084700L ) ) ); } else { value = value.longValue(); expected = 407084700L; @@ -653,50 +426,15 @@ public void test8() throws Throwable { public void test9() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFDepATest.test9"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 159, - (byte) 67, - (byte) 24, - (byte) 177, - (byte) 111, - (byte) 112, - (byte) 45, - (byte) 252, - (byte) 161, - (byte) 68, - (byte) 193, - (byte) 213, - (byte) 168, - (byte) 198, - (byte) 253, - (byte) 73, - (byte) 67, - (byte) 80, - (byte) 193, - (byte) 245, - (byte) 12, - (byte) 228, - (byte) 12, - (byte) 44, - (byte) 163, - (byte) 77, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 8, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x200, payload); - MsgPosECEFDepA msg = new MsgPosECEFDepA(sbp); + byte[] payload = new byte[] {(byte)0,(byte)159,(byte)67,(byte)24,(byte)177,(byte)111,(byte)112,(byte)45,(byte)252,(byte)161,(byte)68,(byte)193,(byte)213,(byte)168,(byte)198,(byte)253,(byte)73,(byte)67,(byte)80,(byte)193,(byte)245,(byte)12,(byte)228,(byte)12,(byte)44,(byte)163,(byte)77,(byte)65,(byte)0,(byte)0,(byte)8,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x200, payload ); + MsgPosECEFDepA msg = new MsgPosECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -704,8 +442,7 @@ public void test9() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -713,8 +450,7 @@ public void test9() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -722,9 +458,7 @@ public void test9() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084800 + "'", - value.equals(BigInteger.valueOf(407084800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084800 + "'", value.equals(BigInteger.valueOf( 407084800L ) ) ); } else { value = value.longValue(); expected = 407084800L; @@ -741,50 +475,15 @@ public void test9() throws Throwable { public void test10() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFDepATest.test10"); - byte[] payload = - new byte[] { - (byte) 100, - (byte) 159, - (byte) 67, - (byte) 24, - (byte) 67, - (byte) 231, - (byte) 72, - (byte) 165, - (byte) 251, - (byte) 161, - (byte) 68, - (byte) 193, - (byte) 150, - (byte) 210, - (byte) 36, - (byte) 212, - (byte) 73, - (byte) 67, - (byte) 80, - (byte) 193, - (byte) 234, - (byte) 33, - (byte) 25, - (byte) 189, - (byte) 43, - (byte) 163, - (byte) 77, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 8, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x200, payload); - MsgPosECEFDepA msg = new MsgPosECEFDepA(sbp); + byte[] payload = new byte[] {(byte)100,(byte)159,(byte)67,(byte)24,(byte)67,(byte)231,(byte)72,(byte)165,(byte)251,(byte)161,(byte)68,(byte)193,(byte)150,(byte)210,(byte)36,(byte)212,(byte)73,(byte)67,(byte)80,(byte)193,(byte)234,(byte)33,(byte)25,(byte)189,(byte)43,(byte)163,(byte)77,(byte)65,(byte)0,(byte)0,(byte)8,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x200, payload ); + MsgPosECEFDepA msg = new MsgPosECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -792,8 +491,7 @@ public void test10() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -801,8 +499,7 @@ public void test10() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -810,9 +507,7 @@ public void test10() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084900 + "'", - value.equals(BigInteger.valueOf(407084900L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084900 + "'", value.equals(BigInteger.valueOf( 407084900L ) ) ); } else { value = value.longValue(); expected = 407084900L; @@ -829,50 +524,15 @@ public void test10() throws Throwable { public void test11() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFDepATest.test11"); - byte[] payload = - new byte[] { - (byte) 46, - (byte) 162, - (byte) 68, - (byte) 24, - (byte) 224, - (byte) 72, - (byte) 131, - (byte) 215, - (byte) 251, - (byte) 161, - (byte) 68, - (byte) 193, - (byte) 180, - (byte) 123, - (byte) 222, - (byte) 94, - (byte) 74, - (byte) 67, - (byte) 80, - (byte) 193, - (byte) 191, - (byte) 3, - (byte) 131, - (byte) 193, - (byte) 45, - (byte) 163, - (byte) 77, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 5, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x200, payload); - MsgPosECEFDepA msg = new MsgPosECEFDepA(sbp); + byte[] payload = new byte[] {(byte)46,(byte)162,(byte)68,(byte)24,(byte)224,(byte)72,(byte)131,(byte)215,(byte)251,(byte)161,(byte)68,(byte)193,(byte)180,(byte)123,(byte)222,(byte)94,(byte)74,(byte)67,(byte)80,(byte)193,(byte)191,(byte)3,(byte)131,(byte)193,(byte)45,(byte)163,(byte)77,(byte)65,(byte)0,(byte)0,(byte)5,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x200, payload ); + MsgPosECEFDepA msg = new MsgPosECEFDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -880,8 +540,7 @@ public void test11() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -889,8 +548,7 @@ public void test11() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -898,9 +556,7 @@ public void test11() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407151150 + "'", - value.equals(BigInteger.valueOf(407151150L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407151150 + "'", value.equals(BigInteger.valueOf( 407151150L ) ) ); } else { value = value.longValue(); expected = 407151150L; diff --git a/java/test/auto_check_sbp_navigation_MsgPosECEFGNSSTest.java b/java/test/auto_check_sbp_navigation_MsgPosECEFGNSSTest.java index 72fc3557f..b7b467c75 100644 --- a/java/test/auto_check_sbp_navigation_MsgPosECEFGNSSTest.java +++ b/java/test/auto_check_sbp_navigation_MsgPosECEFGNSSTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosECEFGNSS.yaml by generate.py. Do not modify by -// hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosECEFGNSS.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgPosECEFGnss; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgPosECEFGNSSTest { @@ -30,24 +34,15 @@ public class auto_check_sbp_navigation_MsgPosECEFGNSSTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFGNSSTest.test1"); - byte[] payload = - new byte[] { - (byte) 24, (byte) 229, (byte) 233, (byte) 29, (byte) 52, (byte) 254, (byte) 158, - (byte) 218, (byte) 42, (byte) 142, (byte) 68, (byte) 193, (byte) 69, (byte) 162, - (byte) 89, (byte) 91, (byte) 34, (byte) 68, (byte) 80, (byte) 193, (byte) 131, - (byte) 21, (byte) 176, (byte) 129, (byte) 239, (byte) 174, (byte) 77, (byte) 65, - (byte) 182, (byte) 0, (byte) 18, (byte) 4, - }; - SBPMessage sbp = new SBPMessage(0x1000, 0x229, payload); - MsgPosECEFGnss msg = new MsgPosECEFGnss(sbp); + byte[] payload = new byte[] {(byte)24,(byte)229,(byte)233,(byte)29,(byte)52,(byte)254,(byte)158,(byte)218,(byte)42,(byte)142,(byte)68,(byte)193,(byte)69,(byte)162,(byte)89,(byte)91,(byte)34,(byte)68,(byte)80,(byte)193,(byte)131,(byte)21,(byte)176,(byte)129,(byte)239,(byte)174,(byte)77,(byte)65,(byte)182,(byte)0,(byte)18,(byte)4, }; + SBPMessage sbp = new SBPMessage( 0x1000, 0x229, payload ); + MsgPosECEFGnss msg = new MsgPosECEFGnss( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -55,8 +50,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -64,8 +58,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 18 + "'", value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -73,9 +66,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 501867800 + "'", - value.equals(BigInteger.valueOf(501867800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 501867800 + "'", value.equals(BigInteger.valueOf( 501867800L ) ) ); } else { value = value.longValue(); expected = 501867800L; diff --git a/java/test/auto_check_sbp_navigation_MsgPosECEFTest.java b/java/test/auto_check_sbp_navigation_MsgPosECEFTest.java index d7243838b..b9eb98140 100644 --- a/java/test/auto_check_sbp_navigation_MsgPosECEFTest.java +++ b/java/test/auto_check_sbp_navigation_MsgPosECEFTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosECEF.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosECEF.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgPosECEF; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgPosECEFTest { @@ -27,51 +32,17 @@ public class auto_check_sbp_navigation_MsgPosECEFTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFTest.test1"); - byte[] payload = - new byte[] { - (byte) 16, - (byte) 248, - (byte) 122, - (byte) 19, - (byte) 73, - (byte) 29, - (byte) 46, - (byte) 132, - (byte) 182, - (byte) 122, - (byte) 68, - (byte) 193, - (byte) 219, - (byte) 192, - (byte) 29, - (byte) 176, - (byte) 121, - (byte) 119, - (byte) 80, - (byte) 193, - (byte) 83, - (byte) 11, - (byte) 210, - (byte) 90, - (byte) 79, - (byte) 75, - (byte) 77, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 15, - (byte) 2, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x209, payload); - MsgPosECEF msg = new MsgPosECEF(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFTest.test1"); + byte[] payload = new byte[] {(byte)16,(byte)248,(byte)122,(byte)19,(byte)73,(byte)29,(byte)46,(byte)132,(byte)182,(byte)122,(byte)68,(byte)193,(byte)219,(byte)192,(byte)29,(byte)176,(byte)121,(byte)119,(byte)80,(byte)193,(byte)83,(byte)11,(byte)210,(byte)90,(byte)79,(byte)75,(byte)77,(byte)65,(byte)0,(byte)0,(byte)15,(byte)2, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x209, payload ); + MsgPosECEF msg = new MsgPosECEF( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -79,8 +50,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -88,8 +58,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -97,9 +66,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326826000 + "'", - value.equals(BigInteger.valueOf(326826000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326826000 + "'", value.equals(BigInteger.valueOf( 326826000L ) ) ); } else { value = value.longValue(); expected = 326826000L; @@ -114,51 +81,17 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFTest.test2"); - byte[] payload = - new byte[] { - (byte) 248, - (byte) 251, - (byte) 122, - (byte) 19, - (byte) 103, - (byte) 106, - (byte) 57, - (byte) 136, - (byte) 182, - (byte) 122, - (byte) 68, - (byte) 193, - (byte) 176, - (byte) 242, - (byte) 200, - (byte) 176, - (byte) 121, - (byte) 119, - (byte) 80, - (byte) 193, - (byte) 244, - (byte) 135, - (byte) 97, - (byte) 59, - (byte) 79, - (byte) 75, - (byte) 77, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 15, - (byte) 2, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x209, payload); - MsgPosECEF msg = new MsgPosECEF(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFTest.test2"); + byte[] payload = new byte[] {(byte)248,(byte)251,(byte)122,(byte)19,(byte)103,(byte)106,(byte)57,(byte)136,(byte)182,(byte)122,(byte)68,(byte)193,(byte)176,(byte)242,(byte)200,(byte)176,(byte)121,(byte)119,(byte)80,(byte)193,(byte)244,(byte)135,(byte)97,(byte)59,(byte)79,(byte)75,(byte)77,(byte)65,(byte)0,(byte)0,(byte)15,(byte)2, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x209, payload ); + MsgPosECEF msg = new MsgPosECEF( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -166,8 +99,7 @@ public void test2() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -175,8 +107,7 @@ public void test2() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -184,9 +115,7 @@ public void test2() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326827000 + "'", - value.equals(BigInteger.valueOf(326827000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326827000 + "'", value.equals(BigInteger.valueOf( 326827000L ) ) ); } else { value = value.longValue(); expected = 326827000L; @@ -201,51 +130,17 @@ public void test2() throws Throwable { @Test public void test3() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFTest.test3"); - byte[] payload = - new byte[] { - (byte) 224, - (byte) 255, - (byte) 122, - (byte) 19, - (byte) 101, - (byte) 179, - (byte) 242, - (byte) 182, - (byte) 182, - (byte) 122, - (byte) 68, - (byte) 193, - (byte) 130, - (byte) 196, - (byte) 145, - (byte) 199, - (byte) 121, - (byte) 119, - (byte) 80, - (byte) 193, - (byte) 212, - (byte) 10, - (byte) 253, - (byte) 15, - (byte) 79, - (byte) 75, - (byte) 77, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 15, - (byte) 2, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x209, payload); - MsgPosECEF msg = new MsgPosECEF(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFTest.test3"); + byte[] payload = new byte[] {(byte)224,(byte)255,(byte)122,(byte)19,(byte)101,(byte)179,(byte)242,(byte)182,(byte)182,(byte)122,(byte)68,(byte)193,(byte)130,(byte)196,(byte)145,(byte)199,(byte)121,(byte)119,(byte)80,(byte)193,(byte)212,(byte)10,(byte)253,(byte)15,(byte)79,(byte)75,(byte)77,(byte)65,(byte)0,(byte)0,(byte)15,(byte)2, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x209, payload ); + MsgPosECEF msg = new MsgPosECEF( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -253,8 +148,7 @@ public void test3() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -262,8 +156,7 @@ public void test3() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -271,9 +164,7 @@ public void test3() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326828000 + "'", - value.equals(BigInteger.valueOf(326828000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326828000 + "'", value.equals(BigInteger.valueOf( 326828000L ) ) ); } else { value = value.longValue(); expected = 326828000L; @@ -288,51 +179,17 @@ public void test3() throws Throwable { @Test public void test4() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFTest.test4"); - byte[] payload = - new byte[] { - (byte) 200, - (byte) 3, - (byte) 123, - (byte) 19, - (byte) 146, - (byte) 214, - (byte) 132, - (byte) 215, - (byte) 182, - (byte) 122, - (byte) 68, - (byte) 193, - (byte) 213, - (byte) 68, - (byte) 49, - (byte) 215, - (byte) 121, - (byte) 119, - (byte) 80, - (byte) 193, - (byte) 71, - (byte) 34, - (byte) 110, - (byte) 243, - (byte) 78, - (byte) 75, - (byte) 77, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 15, - (byte) 2, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x209, payload); - MsgPosECEF msg = new MsgPosECEF(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosECEFTest.test4"); + byte[] payload = new byte[] {(byte)200,(byte)3,(byte)123,(byte)19,(byte)146,(byte)214,(byte)132,(byte)215,(byte)182,(byte)122,(byte)68,(byte)193,(byte)213,(byte)68,(byte)49,(byte)215,(byte)121,(byte)119,(byte)80,(byte)193,(byte)71,(byte)34,(byte)110,(byte)243,(byte)78,(byte)75,(byte)77,(byte)65,(byte)0,(byte)0,(byte)15,(byte)2, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x209, payload ); + MsgPosECEF msg = new MsgPosECEF( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -340,8 +197,7 @@ public void test4() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -349,8 +205,7 @@ public void test4() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -358,9 +213,7 @@ public void test4() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326829000 + "'", - value.equals(BigInteger.valueOf(326829000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326829000 + "'", value.equals(BigInteger.valueOf( 326829000L ) ) ); } else { value = value.longValue(); expected = 326829000L; diff --git a/java/test/auto_check_sbp_navigation_MsgPosLLHCovTest.java b/java/test/auto_check_sbp_navigation_MsgPosLLHCovTest.java index 8de821344..daa232f73 100644 --- a/java/test/auto_check_sbp_navigation_MsgPosLLHCovTest.java +++ b/java/test/auto_check_sbp_navigation_MsgPosLLHCovTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosLLHCov.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosLLHCov.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgPosLLHCov; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgPosLLHCovTest { @@ -27,66 +32,11 @@ public class auto_check_sbp_navigation_MsgPosLLHCovTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHCovTest.test1"); - byte[] payload = - new byte[] { - (byte) 7, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 28, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 224, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 160, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 192, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 128, - (byte) 63, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 64, - (byte) 5, - (byte) 5, - }; - SBPMessage sbp = new SBPMessage(0x42, 0x211, payload); - MsgPosLLHCov msg = new MsgPosLLHCov(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHCovTest.test1"); + byte[] payload = new byte[] {(byte)7,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)28,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)224,(byte)64,(byte)0,(byte)0,(byte)160,(byte)64,(byte)0,(byte)0,(byte)0,(byte)65,(byte)0,(byte)0,(byte)192,(byte)64,(byte)0,(byte)0,(byte)128,(byte)63,(byte)0,(byte)0,(byte)0,(byte)64,(byte)5,(byte)5, }; + SBPMessage sbp = new SBPMessage( 0x42, 0x211, payload ); + MsgPosLLHCov msg = new MsgPosLLHCov( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -98,8 +48,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.cov_n_n, 7.00000000000000000e+00, DELTA); value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -110,8 +59,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.lon, 7.00000000000000000e+00, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -119,8 +67,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 7 + "'", value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; diff --git a/java/test/auto_check_sbp_navigation_MsgPosLLHDepATest.java b/java/test/auto_check_sbp_navigation_MsgPosLLHDepATest.java index 59bd5d2e7..a3a92c133 100644 --- a/java/test/auto_check_sbp_navigation_MsgPosLLHDepATest.java +++ b/java/test/auto_check_sbp_navigation_MsgPosLLHDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosLLHDepA.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosLLHDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgPosLLHDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgPosLLHDepATest { @@ -27,53 +32,17 @@ public class auto_check_sbp_navigation_MsgPosLLHDepATest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 20, - (byte) 46, - (byte) 39, - (byte) 0, - (byte) 250, - (byte) 29, - (byte) 226, - (byte) 186, - (byte) 235, - (byte) 182, - (byte) 66, - (byte) 64, - (byte) 19, - (byte) 203, - (byte) 51, - (byte) 196, - (byte) 24, - (byte) 139, - (byte) 94, - (byte) 192, - (byte) 31, - (byte) 157, - (byte) 160, - (byte) 232, - (byte) 122, - (byte) 115, - (byte) 81, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x201, payload); - MsgPosLLHDepA msg = new MsgPosLLHDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test1"); + byte[] payload = new byte[] {(byte)20,(byte)46,(byte)39,(byte)0,(byte)250,(byte)29,(byte)226,(byte)186,(byte)235,(byte)182,(byte)66,(byte)64,(byte)19,(byte)203,(byte)51,(byte)196,(byte)24,(byte)139,(byte)94,(byte)192,(byte)31,(byte)157,(byte)160,(byte)232,(byte)122,(byte)115,(byte)81,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)9,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x201, payload ); + MsgPosLLHDepA msg = new MsgPosLLHDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -81,9 +50,7 @@ public void test1() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -94,8 +61,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22173386622027735e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -103,9 +69,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567700 + "'", - value.equals(BigInteger.valueOf(2567700L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567700 + "'", value.equals(BigInteger.valueOf( 2567700L ) ) ); } else { value = value.longValue(); expected = 2567700L; @@ -113,9 +77,7 @@ public void test1() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -127,24 +89,17 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test2"); - byte[] payload = - new byte[] { - (byte) 20, (byte) 46, (byte) 39, (byte) 0, (byte) 161, (byte) 51, (byte) 75, - (byte) 148, (byte) 235, (byte) 182, (byte) 66, (byte) 64, (byte) 36, (byte) 41, - (byte) 246, (byte) 30, (byte) 25, (byte) 139, (byte) 94, (byte) 192, (byte) 254, - (byte) 218, (byte) 49, (byte) 127, (byte) 10, (byte) 108, (byte) 81, (byte) 64, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 9, (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x201, payload); - MsgPosLLHDepA msg = new MsgPosLLHDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test2"); + byte[] payload = new byte[] {(byte)20,(byte)46,(byte)39,(byte)0,(byte)161,(byte)51,(byte)75,(byte)148,(byte)235,(byte)182,(byte)66,(byte)64,(byte)36,(byte)41,(byte)246,(byte)30,(byte)25,(byte)139,(byte)94,(byte)192,(byte)254,(byte)218,(byte)49,(byte)127,(byte)10,(byte)108,(byte)81,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x201, payload ); + MsgPosLLHDepA msg = new MsgPosLLHDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -152,9 +107,7 @@ public void test2() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -165,8 +118,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22173408260718645e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -174,9 +126,7 @@ public void test2() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567700 + "'", - value.equals(BigInteger.valueOf(2567700L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567700 + "'", value.equals(BigInteger.valueOf( 2567700L ) ) ); } else { value = value.longValue(); expected = 2567700L; @@ -184,9 +134,7 @@ public void test2() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -198,24 +146,17 @@ public void test2() throws Throwable { @Test public void test3() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test3"); - byte[] payload = - new byte[] { - (byte) 120, (byte) 46, (byte) 39, (byte) 0, (byte) 56, (byte) 214, (byte) 210, - (byte) 65, (byte) 235, (byte) 182, (byte) 66, (byte) 64, (byte) 13, (byte) 46, - (byte) 132, (byte) 80, (byte) 25, (byte) 139, (byte) 94, (byte) 192, (byte) 22, - (byte) 143, (byte) 46, (byte) 234, (byte) 191, (byte) 95, (byte) 81, (byte) 64, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 9, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x201, payload); - MsgPosLLHDepA msg = new MsgPosLLHDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test3"); + byte[] payload = new byte[] {(byte)120,(byte)46,(byte)39,(byte)0,(byte)56,(byte)214,(byte)210,(byte)65,(byte)235,(byte)182,(byte)66,(byte)64,(byte)13,(byte)46,(byte)132,(byte)80,(byte)25,(byte)139,(byte)94,(byte)192,(byte)22,(byte)143,(byte)46,(byte)234,(byte)191,(byte)95,(byte)81,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)9,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x201, payload ); + MsgPosLLHDepA msg = new MsgPosLLHDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -223,9 +164,7 @@ public void test3() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -236,8 +175,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22173420075494690e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -245,9 +183,7 @@ public void test3() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567800 + "'", - value.equals(BigInteger.valueOf(2567800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567800 + "'", value.equals(BigInteger.valueOf( 2567800L ) ) ); } else { value = value.longValue(); expected = 2567800L; @@ -255,9 +191,7 @@ public void test3() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -269,53 +203,17 @@ public void test3() throws Throwable { @Test public void test4() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test4"); - byte[] payload = - new byte[] { - (byte) 120, - (byte) 46, - (byte) 39, - (byte) 0, - (byte) 251, - (byte) 117, - (byte) 115, - (byte) 140, - (byte) 235, - (byte) 182, - (byte) 66, - (byte) 64, - (byte) 152, - (byte) 134, - (byte) 167, - (byte) 12, - (byte) 25, - (byte) 139, - (byte) 94, - (byte) 192, - (byte) 160, - (byte) 22, - (byte) 137, - (byte) 253, - (byte) 4, - (byte) 108, - (byte) 81, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x201, payload); - MsgPosLLHDepA msg = new MsgPosLLHDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test4"); + byte[] payload = new byte[] {(byte)120,(byte)46,(byte)39,(byte)0,(byte)251,(byte)117,(byte)115,(byte)140,(byte)235,(byte)182,(byte)66,(byte)64,(byte)152,(byte)134,(byte)167,(byte)12,(byte)25,(byte)139,(byte)94,(byte)192,(byte)160,(byte)22,(byte)137,(byte)253,(byte)4,(byte)108,(byte)81,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)9,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x201, payload ); + MsgPosLLHDepA msg = new MsgPosLLHDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -323,9 +221,7 @@ public void test4() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -336,8 +232,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22173403895949718e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -345,9 +240,7 @@ public void test4() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567800 + "'", - value.equals(BigInteger.valueOf(2567800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567800 + "'", value.equals(BigInteger.valueOf( 2567800L ) ) ); } else { value = value.longValue(); expected = 2567800L; @@ -355,9 +248,7 @@ public void test4() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -369,24 +260,17 @@ public void test4() throws Throwable { @Test public void test5() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test5"); - byte[] payload = - new byte[] { - (byte) 220, (byte) 46, (byte) 39, (byte) 0, (byte) 51, (byte) 124, (byte) 88, - (byte) 251, (byte) 235, (byte) 182, (byte) 66, (byte) 64, (byte) 153, (byte) 5, - (byte) 250, (byte) 16, (byte) 25, (byte) 139, (byte) 94, (byte) 192, (byte) 146, - (byte) 60, (byte) 187, (byte) 219, (byte) 152, (byte) 161, (byte) 81, (byte) 64, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 9, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x201, payload); - MsgPosLLHDepA msg = new MsgPosLLHDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test5"); + byte[] payload = new byte[] {(byte)220,(byte)46,(byte)39,(byte)0,(byte)51,(byte)124,(byte)88,(byte)251,(byte)235,(byte)182,(byte)66,(byte)64,(byte)153,(byte)5,(byte)250,(byte)16,(byte)25,(byte)139,(byte)94,(byte)192,(byte)146,(byte)60,(byte)187,(byte)219,(byte)152,(byte)161,(byte)81,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)9,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x201, payload ); + MsgPosLLHDepA msg = new MsgPosLLHDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -394,9 +278,7 @@ public void test5() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -407,8 +289,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22173404926454523e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -416,9 +297,7 @@ public void test5() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 2567900 + "'", - value.equals(BigInteger.valueOf(2567900L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 2567900 + "'", value.equals(BigInteger.valueOf( 2567900L ) ) ); } else { value = value.longValue(); expected = 2567900L; @@ -426,9 +305,7 @@ public void test5() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -440,53 +317,17 @@ public void test5() throws Throwable { @Test public void test6() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test6"); - byte[] payload = - new byte[] { - (byte) 212, - (byte) 157, - (byte) 67, - (byte) 24, - (byte) 8, - (byte) 23, - (byte) 228, - (byte) 8, - (byte) 151, - (byte) 225, - (byte) 66, - (byte) 64, - (byte) 156, - (byte) 174, - (byte) 42, - (byte) 194, - (byte) 230, - (byte) 152, - (byte) 94, - (byte) 192, - (byte) 153, - (byte) 23, - (byte) 72, - (byte) 47, - (byte) 196, - (byte) 40, - (byte) 16, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 8, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x201, payload); - MsgPosLLHDepA msg = new MsgPosLLHDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test6"); + byte[] payload = new byte[] {(byte)212,(byte)157,(byte)67,(byte)24,(byte)8,(byte)23,(byte)228,(byte)8,(byte)151,(byte)225,(byte)66,(byte)64,(byte)156,(byte)174,(byte)42,(byte)194,(byte)230,(byte)152,(byte)94,(byte)192,(byte)153,(byte)23,(byte)72,(byte)47,(byte)196,(byte)40,(byte)16,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)8,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x201, payload ); + MsgPosLLHDepA msg = new MsgPosLLHDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -494,9 +335,7 @@ public void test6() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -507,8 +346,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22389084378892619e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -516,9 +354,7 @@ public void test6() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084500 + "'", - value.equals(BigInteger.valueOf(407084500L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084500 + "'", value.equals(BigInteger.valueOf( 407084500L ) ) ); } else { value = value.longValue(); expected = 407084500L; @@ -526,9 +362,7 @@ public void test6() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -540,53 +374,17 @@ public void test6() throws Throwable { @Test public void test7() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test7"); - byte[] payload = - new byte[] { - (byte) 56, - (byte) 158, - (byte) 67, - (byte) 24, - (byte) 220, - (byte) 109, - (byte) 212, - (byte) 24, - (byte) 151, - (byte) 225, - (byte) 66, - (byte) 64, - (byte) 159, - (byte) 231, - (byte) 254, - (byte) 219, - (byte) 230, - (byte) 152, - (byte) 94, - (byte) 192, - (byte) 128, - (byte) 151, - (byte) 67, - (byte) 19, - (byte) 233, - (byte) 105, - (byte) 7, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 8, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x201, payload); - MsgPosLLHDepA msg = new MsgPosLLHDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test7"); + byte[] payload = new byte[] {(byte)56,(byte)158,(byte)67,(byte)24,(byte)220,(byte)109,(byte)212,(byte)24,(byte)151,(byte)225,(byte)66,(byte)64,(byte)159,(byte)231,(byte)254,(byte)219,(byte)230,(byte)152,(byte)94,(byte)192,(byte)128,(byte)151,(byte)67,(byte)19,(byte)233,(byte)105,(byte)7,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)8,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x201, payload ); + MsgPosLLHDepA msg = new MsgPosLLHDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -594,9 +392,7 @@ public void test7() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -607,8 +403,7 @@ public void test7() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22389090537004890e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -616,9 +411,7 @@ public void test7() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084600 + "'", - value.equals(BigInteger.valueOf(407084600L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084600 + "'", value.equals(BigInteger.valueOf( 407084600L ) ) ); } else { value = value.longValue(); expected = 407084600L; @@ -626,9 +419,7 @@ public void test7() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -640,53 +431,17 @@ public void test7() throws Throwable { @Test public void test8() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test8"); - byte[] payload = - new byte[] { - (byte) 156, - (byte) 158, - (byte) 67, - (byte) 24, - (byte) 13, - (byte) 91, - (byte) 237, - (byte) 11, - (byte) 151, - (byte) 225, - (byte) 66, - (byte) 64, - (byte) 75, - (byte) 113, - (byte) 210, - (byte) 220, - (byte) 230, - (byte) 152, - (byte) 94, - (byte) 192, - (byte) 37, - (byte) 6, - (byte) 145, - (byte) 188, - (byte) 89, - (byte) 112, - (byte) 238, - (byte) 63, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 8, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x201, payload); - MsgPosLLHDepA msg = new MsgPosLLHDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test8"); + byte[] payload = new byte[] {(byte)156,(byte)158,(byte)67,(byte)24,(byte)13,(byte)91,(byte)237,(byte)11,(byte)151,(byte)225,(byte)66,(byte)64,(byte)75,(byte)113,(byte)210,(byte)220,(byte)230,(byte)152,(byte)94,(byte)192,(byte)37,(byte)6,(byte)145,(byte)188,(byte)89,(byte)112,(byte)238,(byte)63,(byte)0,(byte)0,(byte)0,(byte)0,(byte)8,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x201, payload ); + MsgPosLLHDepA msg = new MsgPosLLHDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -694,9 +449,7 @@ public void test8() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -707,8 +460,7 @@ public void test8() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22389090734014800e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -716,9 +468,7 @@ public void test8() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084700 + "'", - value.equals(BigInteger.valueOf(407084700L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084700 + "'", value.equals(BigInteger.valueOf( 407084700L ) ) ); } else { value = value.longValue(); expected = 407084700L; @@ -726,9 +476,7 @@ public void test8() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -740,53 +488,17 @@ public void test8() throws Throwable { @Test public void test9() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test9"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 159, - (byte) 67, - (byte) 24, - (byte) 51, - (byte) 183, - (byte) 5, - (byte) 8, - (byte) 151, - (byte) 225, - (byte) 66, - (byte) 64, - (byte) 13, - (byte) 226, - (byte) 148, - (byte) 253, - (byte) 230, - (byte) 152, - (byte) 94, - (byte) 192, - (byte) 187, - (byte) 27, - (byte) 11, - (byte) 32, - (byte) 69, - (byte) 213, - (byte) 2, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 8, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x201, payload); - MsgPosLLHDepA msg = new MsgPosLLHDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test9"); + byte[] payload = new byte[] {(byte)0,(byte)159,(byte)67,(byte)24,(byte)51,(byte)183,(byte)5,(byte)8,(byte)151,(byte)225,(byte)66,(byte)64,(byte)13,(byte)226,(byte)148,(byte)253,(byte)230,(byte)152,(byte)94,(byte)192,(byte)187,(byte)27,(byte)11,(byte)32,(byte)69,(byte)213,(byte)2,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)8,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x201, payload ); + MsgPosLLHDepA msg = new MsgPosLLHDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -794,9 +506,7 @@ public void test9() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -807,8 +517,7 @@ public void test9() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22389098544496122e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -816,9 +525,7 @@ public void test9() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084800 + "'", - value.equals(BigInteger.valueOf(407084800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084800 + "'", value.equals(BigInteger.valueOf( 407084800L ) ) ); } else { value = value.longValue(); expected = 407084800L; @@ -826,9 +533,7 @@ public void test9() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -842,52 +547,15 @@ public void test9() throws Throwable { public void test10() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test10"); - byte[] payload = - new byte[] { - (byte) 100, - (byte) 159, - (byte) 67, - (byte) 24, - (byte) 22, - (byte) 77, - (byte) 146, - (byte) 22, - (byte) 151, - (byte) 225, - (byte) 66, - (byte) 64, - (byte) 64, - (byte) 134, - (byte) 105, - (byte) 227, - (byte) 230, - (byte) 152, - (byte) 94, - (byte) 192, - (byte) 37, - (byte) 99, - (byte) 114, - (byte) 72, - (byte) 31, - (byte) 103, - (byte) 241, - (byte) 63, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 8, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x201, payload); - MsgPosLLHDepA msg = new MsgPosLLHDepA(sbp); + byte[] payload = new byte[] {(byte)100,(byte)159,(byte)67,(byte)24,(byte)22,(byte)77,(byte)146,(byte)22,(byte)151,(byte)225,(byte)66,(byte)64,(byte)64,(byte)134,(byte)105,(byte)227,(byte)230,(byte)152,(byte)94,(byte)192,(byte)37,(byte)99,(byte)114,(byte)72,(byte)31,(byte)103,(byte)241,(byte)63,(byte)0,(byte)0,(byte)0,(byte)0,(byte)8,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x201, payload ); + MsgPosLLHDepA msg = new MsgPosLLHDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -895,9 +563,7 @@ public void test10() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -908,8 +574,7 @@ public void test10() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22389092305232225e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -917,9 +582,7 @@ public void test10() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407084900 + "'", - value.equals(BigInteger.valueOf(407084900L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407084900 + "'", value.equals(BigInteger.valueOf( 407084900L ) ) ); } else { value = value.longValue(); expected = 407084900L; @@ -927,9 +590,7 @@ public void test10() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -943,52 +604,15 @@ public void test10() throws Throwable { public void test11() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHDepATest.test11"); - byte[] payload = - new byte[] { - (byte) 46, - (byte) 162, - (byte) 68, - (byte) 24, - (byte) 124, - (byte) 245, - (byte) 46, - (byte) 169, - (byte) 151, - (byte) 225, - (byte) 66, - (byte) 64, - (byte) 135, - (byte) 149, - (byte) 234, - (byte) 187, - (byte) 230, - (byte) 152, - (byte) 94, - (byte) 192, - (byte) 194, - (byte) 201, - (byte) 115, - (byte) 145, - (byte) 166, - (byte) 175, - (byte) 20, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 5, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x201, payload); - MsgPosLLHDepA msg = new MsgPosLLHDepA(sbp); + byte[] payload = new byte[] {(byte)46,(byte)162,(byte)68,(byte)24,(byte)124,(byte)245,(byte)46,(byte)169,(byte)151,(byte)225,(byte)66,(byte)64,(byte)135,(byte)149,(byte)234,(byte)187,(byte)230,(byte)152,(byte)94,(byte)192,(byte)194,(byte)201,(byte)115,(byte)145,(byte)166,(byte)175,(byte)20,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)5,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x201, payload ); + MsgPosLLHDepA msg = new MsgPosLLHDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -996,9 +620,7 @@ public void test11() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1009,8 +631,7 @@ public void test11() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22389082888685252e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -1018,9 +639,7 @@ public void test11() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 407151150 + "'", - value.equals(BigInteger.valueOf(407151150L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 407151150 + "'", value.equals(BigInteger.valueOf( 407151150L ) ) ); } else { value = value.longValue(); expected = 407151150L; @@ -1028,9 +647,7 @@ public void test11() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; diff --git a/java/test/auto_check_sbp_navigation_MsgPosLLHTest.java b/java/test/auto_check_sbp_navigation_MsgPosLLHTest.java index 5687df4be..50e3a9004 100644 --- a/java/test/auto_check_sbp_navigation_MsgPosLLHTest.java +++ b/java/test/auto_check_sbp_navigation_MsgPosLLHTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosLLH.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosLLH.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgPosLLH; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgPosLLHTest { @@ -27,53 +32,17 @@ public class auto_check_sbp_navigation_MsgPosLLHTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHTest.test1"); - byte[] payload = - new byte[] { - (byte) 40, - (byte) 244, - (byte) 122, - (byte) 19, - (byte) 201, - (byte) 106, - (byte) 155, - (byte) 186, - (byte) 42, - (byte) 160, - (byte) 66, - (byte) 64, - (byte) 168, - (byte) 109, - (byte) 26, - (byte) 225, - (byte) 0, - (byte) 120, - (byte) 94, - (byte) 192, - (byte) 130, - (byte) 102, - (byte) 237, - (byte) 230, - (byte) 43, - (byte) 54, - (byte) 60, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 14, - (byte) 2, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20a, payload); - MsgPosLLH msg = new MsgPosLLH(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHTest.test1"); + byte[] payload = new byte[] {(byte)40,(byte)244,(byte)122,(byte)19,(byte)201,(byte)106,(byte)155,(byte)186,(byte)42,(byte)160,(byte)66,(byte)64,(byte)168,(byte)109,(byte)26,(byte)225,(byte)0,(byte)120,(byte)94,(byte)192,(byte)130,(byte)102,(byte)237,(byte)230,(byte)43,(byte)54,(byte)60,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)14,(byte)2, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20a, payload ); + MsgPosLLH msg = new MsgPosLLH( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -81,9 +50,7 @@ public void test1() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -94,8 +61,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.21875053668793612e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 14 + "'", value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -103,9 +69,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326825000 + "'", - value.equals(BigInteger.valueOf(326825000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326825000 + "'", value.equals(BigInteger.valueOf( 326825000L ) ) ); } else { value = value.longValue(); expected = 326825000L; @@ -113,9 +77,7 @@ public void test1() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -127,24 +89,17 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHTest.test2"); - byte[] payload = - new byte[] { - (byte) 16, (byte) 248, (byte) 122, (byte) 19, (byte) 52, (byte) 177, (byte) 251, - (byte) 178, (byte) 42, (byte) 160, (byte) 66, (byte) 64, (byte) 237, (byte) 22, - (byte) 97, (byte) 224, (byte) 0, (byte) 120, (byte) 94, (byte) 192, (byte) 107, - (byte) 188, (byte) 109, (byte) 90, (byte) 247, (byte) 189, (byte) 59, (byte) 64, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 15, (byte) 2, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20a, payload); - MsgPosLLH msg = new MsgPosLLH(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHTest.test2"); + byte[] payload = new byte[] {(byte)16,(byte)248,(byte)122,(byte)19,(byte)52,(byte)177,(byte)251,(byte)178,(byte)42,(byte)160,(byte)66,(byte)64,(byte)237,(byte)22,(byte)97,(byte)224,(byte)0,(byte)120,(byte)94,(byte)192,(byte)107,(byte)188,(byte)109,(byte)90,(byte)247,(byte)189,(byte)59,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)15,(byte)2, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20a, payload ); + MsgPosLLH msg = new MsgPosLLH( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -152,9 +107,7 @@ public void test2() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -165,8 +118,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.21875053496183412e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -174,9 +126,7 @@ public void test2() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326826000 + "'", - value.equals(BigInteger.valueOf(326826000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326826000 + "'", value.equals(BigInteger.valueOf( 326826000L ) ) ); } else { value = value.longValue(); expected = 326826000L; @@ -184,9 +134,7 @@ public void test2() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -198,24 +146,17 @@ public void test2() throws Throwable { @Test public void test3() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHTest.test3"); - byte[] payload = - new byte[] { - (byte) 248, (byte) 251, (byte) 122, (byte) 19, (byte) 135, (byte) 66, (byte) 9, - (byte) 163, (byte) 42, (byte) 160, (byte) 66, (byte) 64, (byte) 146, (byte) 8, - (byte) 99, (byte) 225, (byte) 0, (byte) 120, (byte) 94, (byte) 192, (byte) 45, - (byte) 181, (byte) 143, (byte) 219, (byte) 28, (byte) 157, (byte) 59, (byte) 64, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 15, (byte) 2, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20a, payload); - MsgPosLLH msg = new MsgPosLLH(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHTest.test3"); + byte[] payload = new byte[] {(byte)248,(byte)251,(byte)122,(byte)19,(byte)135,(byte)66,(byte)9,(byte)163,(byte)42,(byte)160,(byte)66,(byte)64,(byte)146,(byte)8,(byte)99,(byte)225,(byte)0,(byte)120,(byte)94,(byte)192,(byte)45,(byte)181,(byte)143,(byte)219,(byte)28,(byte)157,(byte)59,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)15,(byte)2, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20a, payload ); + MsgPosLLH msg = new MsgPosLLH( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -223,9 +164,7 @@ public void test3() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -236,8 +175,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.21875053736412411e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -245,9 +183,7 @@ public void test3() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326827000 + "'", - value.equals(BigInteger.valueOf(326827000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326827000 + "'", value.equals(BigInteger.valueOf( 326827000L ) ) ); } else { value = value.longValue(); expected = 326827000L; @@ -255,9 +191,7 @@ public void test3() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -269,24 +203,17 @@ public void test3() throws Throwable { @Test public void test4() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHTest.test4"); - byte[] payload = - new byte[] { - (byte) 224, (byte) 255, (byte) 122, (byte) 19, (byte) 18, (byte) 44, (byte) 253, - (byte) 119, (byte) 42, (byte) 160, (byte) 66, (byte) 64, (byte) 48, (byte) 109, - (byte) 39, (byte) 231, (byte) 0, (byte) 120, (byte) 94, (byte) 192, (byte) 185, - (byte) 76, (byte) 48, (byte) 17, (byte) 119, (byte) 205, (byte) 59, (byte) 64, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 15, (byte) 2, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20a, payload); - MsgPosLLH msg = new MsgPosLLH(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHTest.test4"); + byte[] payload = new byte[] {(byte)224,(byte)255,(byte)122,(byte)19,(byte)18,(byte)44,(byte)253,(byte)119,(byte)42,(byte)160,(byte)66,(byte)64,(byte)48,(byte)109,(byte)39,(byte)231,(byte)0,(byte)120,(byte)94,(byte)192,(byte)185,(byte)76,(byte)48,(byte)17,(byte)119,(byte)205,(byte)59,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)15,(byte)2, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20a, payload ); + MsgPosLLH msg = new MsgPosLLH( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -294,9 +221,7 @@ public void test4() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -307,8 +232,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.21875055111410575e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -316,9 +240,7 @@ public void test4() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326828000 + "'", - value.equals(BigInteger.valueOf(326828000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326828000 + "'", value.equals(BigInteger.valueOf( 326828000L ) ) ); } else { value = value.longValue(); expected = 326828000L; @@ -326,9 +248,7 @@ public void test4() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -340,53 +260,17 @@ public void test4() throws Throwable { @Test public void test5() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHTest.test5"); - byte[] payload = - new byte[] { - (byte) 200, - (byte) 3, - (byte) 123, - (byte) 19, - (byte) 225, - (byte) 237, - (byte) 238, - (byte) 90, - (byte) 42, - (byte) 160, - (byte) 66, - (byte) 64, - (byte) 59, - (byte) 143, - (byte) 70, - (byte) 235, - (byte) 0, - (byte) 120, - (byte) 94, - (byte) 192, - (byte) 101, - (byte) 106, - (byte) 249, - (byte) 224, - (byte) 131, - (byte) 240, - (byte) 59, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 15, - (byte) 2, - }; - SBPMessage sbp = new SBPMessage(0x88d3, 0x20a, payload); - MsgPosLLH msg = new MsgPosLLH(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLLHTest.test5"); + byte[] payload = new byte[] {(byte)200,(byte)3,(byte)123,(byte)19,(byte)225,(byte)237,(byte)238,(byte)90,(byte)42,(byte)160,(byte)66,(byte)64,(byte)59,(byte)143,(byte)70,(byte)235,(byte)0,(byte)120,(byte)94,(byte)192,(byte)101,(byte)106,(byte)249,(byte)224,(byte)131,(byte)240,(byte)59,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)15,(byte)2, }; + SBPMessage sbp = new SBPMessage( 0x88d3, 0x20a, payload ); + MsgPosLLH msg = new MsgPosLLH( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -394,9 +278,7 @@ public void test5() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -407,8 +289,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.21875056094079739e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -416,9 +297,7 @@ public void test5() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 326829000 + "'", - value.equals(BigInteger.valueOf(326829000L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 326829000 + "'", value.equals(BigInteger.valueOf( 326829000L ) ) ); } else { value = value.longValue(); expected = 326829000L; @@ -426,9 +305,7 @@ public void test5() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; diff --git a/java/test/auto_check_sbp_navigation_MsgPosLlhAccTest.java b/java/test/auto_check_sbp_navigation_MsgPosLlhAccTest.java index a8d5d940d..99a0855a3 100644 --- a/java/test/auto_check_sbp_navigation_MsgPosLlhAccTest.java +++ b/java/test/auto_check_sbp_navigation_MsgPosLlhAccTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosLlhAcc.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosLlhAcc.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgPosLLHAcc; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgPosLlhAccTest { @@ -27,88 +32,18 @@ public class auto_check_sbp_navigation_MsgPosLlhAccTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLlhAccTest.test1"); - byte[] payload = - new byte[] { - (byte) 39, - (byte) 120, - (byte) 110, - (byte) 18, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 139, - (byte) 189, - (byte) 64, - (byte) 154, - (byte) 153, - (byte) 153, - (byte) 153, - (byte) 25, - (byte) 151, - (byte) 192, - (byte) 64, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 161, - (byte) 176, - (byte) 64, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 101, - (byte) 179, - (byte) 64, - (byte) 51, - (byte) 163, - (byte) 22, - (byte) 69, - (byte) 154, - (byte) 25, - (byte) 173, - (byte) 69, - (byte) 102, - (byte) 134, - (byte) 243, - (byte) 68, - (byte) 154, - (byte) 201, - (byte) 196, - (byte) 69, - (byte) 205, - (byte) 224, - (byte) 0, - (byte) 70, - (byte) 51, - (byte) 35, - (byte) 72, - (byte) 69, - (byte) 51, - (byte) 99, - (byte) 31, - (byte) 69, - (byte) 95, - (byte) 27, - (byte) 72, - }; - SBPMessage sbp = new SBPMessage(0x1c02, 0x218, payload); - MsgPosLLHAcc msg = new MsgPosLLHAcc(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLlhAccTest.test1"); + byte[] payload = new byte[] {(byte)39,(byte)120,(byte)110,(byte)18,(byte)51,(byte)51,(byte)51,(byte)51,(byte)51,(byte)139,(byte)189,(byte)64,(byte)154,(byte)153,(byte)153,(byte)153,(byte)25,(byte)151,(byte)192,(byte)64,(byte)51,(byte)51,(byte)51,(byte)51,(byte)51,(byte)161,(byte)176,(byte)64,(byte)51,(byte)51,(byte)51,(byte)51,(byte)51,(byte)101,(byte)179,(byte)64,(byte)51,(byte)163,(byte)22,(byte)69,(byte)154,(byte)25,(byte)173,(byte)69,(byte)102,(byte)134,(byte)243,(byte)68,(byte)154,(byte)201,(byte)196,(byte)69,(byte)205,(byte)224,(byte)0,(byte)70,(byte)51,(byte)35,(byte)72,(byte)69,(byte)51,(byte)99,(byte)31,(byte)69,(byte)95,(byte)27,(byte)72, }; + SBPMessage sbp = new SBPMessage( 0x1c02, 0x218, payload ); + MsgPosLLHAcc msg = new MsgPosLLHAcc( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.at_accuracy, 6.29720019531250000e+03, DELTA); value = msg.confidence_and_geoid; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.confidence_and_geoid + "' != '" + 95 + "'", - value.equals(BigInteger.valueOf(95L))); + org.junit.Assert.assertTrue("'" + msg.confidence_and_geoid + "' != '" + 95 + "'", value.equals(BigInteger.valueOf( 95L ) ) ); } else { value = value.longValue(); expected = 95L; @@ -117,8 +52,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.ct_accuracy, 1.94819995117187500e+03, DELTA); value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 72 + "'", value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -133,8 +67,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.lon, 8.49420000000000073e+03, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 27 + "'", value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -143,9 +76,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.orthometric_height, 4.96519999999999982e+03, DELTA); value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 309229607 + "'", - value.equals(BigInteger.valueOf(309229607L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 309229607 + "'", value.equals(BigInteger.valueOf( 309229607L ) ) ); } else { value = value.longValue(); expected = 309229607L; diff --git a/java/test/auto_check_sbp_navigation_MsgPosLlhCovGnssTest.java b/java/test/auto_check_sbp_navigation_MsgPosLlhCovGnssTest.java index 022cc536e..337142f1b 100644 --- a/java/test/auto_check_sbp_navigation_MsgPosLlhCovGnssTest.java +++ b/java/test/auto_check_sbp_navigation_MsgPosLlhCovGnssTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosLlhCovGnss.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosLlhCovGnss.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgPosLLHCovGnss; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgPosLlhCovGnssTest { @@ -30,65 +34,9 @@ public class auto_check_sbp_navigation_MsgPosLlhCovGnssTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLlhCovGnssTest.test1"); - byte[] payload = - new byte[] { - (byte) 24, - (byte) 229, - (byte) 233, - (byte) 29, - (byte) 73, - (byte) 123, - (byte) 28, - (byte) 207, - (byte) 101, - (byte) 234, - (byte) 66, - (byte) 64, - (byte) 100, - (byte) 168, - (byte) 19, - (byte) 20, - (byte) 86, - (byte) 146, - (byte) 94, - (byte) 192, - (byte) 214, - (byte) 198, - (byte) 35, - (byte) 120, - (byte) 209, - (byte) 100, - (byte) 49, - (byte) 192, - (byte) 12, - (byte) 102, - (byte) 245, - (byte) 59, - (byte) 6, - (byte) 181, - (byte) 192, - (byte) 185, - (byte) 168, - (byte) 79, - (byte) 243, - (byte) 58, - (byte) 96, - (byte) 60, - (byte) 148, - (byte) 59, - (byte) 253, - (byte) 58, - (byte) 93, - (byte) 186, - (byte) 159, - (byte) 174, - (byte) 6, - (byte) 61, - (byte) 18, - (byte) 4, - }; - SBPMessage sbp = new SBPMessage(0x1000, 0x231, payload); - MsgPosLLHCovGnss msg = new MsgPosLLHCovGnss(sbp); + byte[] payload = new byte[] {(byte)24,(byte)229,(byte)233,(byte)29,(byte)73,(byte)123,(byte)28,(byte)207,(byte)101,(byte)234,(byte)66,(byte)64,(byte)100,(byte)168,(byte)19,(byte)20,(byte)86,(byte)146,(byte)94,(byte)192,(byte)214,(byte)198,(byte)35,(byte)120,(byte)209,(byte)100,(byte)49,(byte)192,(byte)12,(byte)102,(byte)245,(byte)59,(byte)6,(byte)181,(byte)192,(byte)185,(byte)168,(byte)79,(byte)243,(byte)58,(byte)96,(byte)60,(byte)148,(byte)59,(byte)253,(byte)58,(byte)93,(byte)186,(byte)159,(byte)174,(byte)6,(byte)61,(byte)18,(byte)4, }; + SBPMessage sbp = new SBPMessage( 0x1000, 0x231, payload ); + MsgPosLLHCovGnss msg = new MsgPosLLHCovGnss( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -100,8 +48,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.cov_n_n, 7.48897157609462738e-03, DELTA); value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -112,8 +59,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22286503810116812e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 18 + "'", value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -121,9 +67,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 501867800 + "'", - value.equals(BigInteger.valueOf(501867800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 501867800 + "'", value.equals(BigInteger.valueOf( 501867800L ) ) ); } else { value = value.longValue(); expected = 501867800L; diff --git a/java/test/auto_check_sbp_navigation_MsgPosLlhGnssTest.java b/java/test/auto_check_sbp_navigation_MsgPosLlhGnssTest.java index b65652e79..01e3a4980 100644 --- a/java/test/auto_check_sbp_navigation_MsgPosLlhGnssTest.java +++ b/java/test/auto_check_sbp_navigation_MsgPosLlhGnssTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosLlhGnss.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPosLlhGnss.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgPosLLHGnss; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgPosLlhGnssTest { @@ -27,53 +32,17 @@ public class auto_check_sbp_navigation_MsgPosLlhGnssTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLlhGnssTest.test1"); - byte[] payload = - new byte[] { - (byte) 24, - (byte) 229, - (byte) 233, - (byte) 29, - (byte) 73, - (byte) 123, - (byte) 28, - (byte) 207, - (byte) 101, - (byte) 234, - (byte) 66, - (byte) 64, - (byte) 100, - (byte) 168, - (byte) 19, - (byte) 20, - (byte) 86, - (byte) 146, - (byte) 94, - (byte) 192, - (byte) 214, - (byte) 198, - (byte) 35, - (byte) 120, - (byte) 209, - (byte) 100, - (byte) 49, - (byte) 192, - (byte) 87, - (byte) 0, - (byte) 181, - (byte) 0, - (byte) 18, - (byte) 4, - }; - SBPMessage sbp = new SBPMessage(0x1000, 0x22a, payload); - MsgPosLLHGnss msg = new MsgPosLLHGnss(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPosLlhGnssTest.test1"); + byte[] payload = new byte[] {(byte)24,(byte)229,(byte)233,(byte)29,(byte)73,(byte)123,(byte)28,(byte)207,(byte)101,(byte)234,(byte)66,(byte)64,(byte)100,(byte)168,(byte)19,(byte)20,(byte)86,(byte)146,(byte)94,(byte)192,(byte)214,(byte)198,(byte)35,(byte)120,(byte)209,(byte)100,(byte)49,(byte)192,(byte)87,(byte)0,(byte)181,(byte)0,(byte)18,(byte)4, }; + SBPMessage sbp = new SBPMessage( 0x1000, 0x22a, payload ); + MsgPosLLHGnss msg = new MsgPosLLHGnss( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 4 + "'", value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -81,9 +50,7 @@ public void test1() throws Throwable { } value = msg.h_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.h_accuracy + "' != '" + 87 + "'", - value.equals(BigInteger.valueOf(87L))); + org.junit.Assert.assertTrue("'" + msg.h_accuracy + "' != '" + 87 + "'", value.equals(BigInteger.valueOf( 87L ) ) ); } else { value = value.longValue(); expected = 87L; @@ -94,8 +61,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.lon, -1.22286503810116812e+02, DELTA); value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 18 + "'", value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -103,9 +69,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 501867800 + "'", - value.equals(BigInteger.valueOf(501867800L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 501867800 + "'", value.equals(BigInteger.valueOf( 501867800L ) ) ); } else { value = value.longValue(); expected = 501867800L; @@ -113,9 +77,7 @@ public void test1() throws Throwable { } value = msg.v_accuracy; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_accuracy + "' != '" + 181 + "'", - value.equals(BigInteger.valueOf(181L))); + org.junit.Assert.assertTrue("'" + msg.v_accuracy + "' != '" + 181 + "'", value.equals(BigInteger.valueOf( 181L ) ) ); } else { value = value.longValue(); expected = 181L; diff --git a/java/test/auto_check_sbp_navigation_MsgPoseRelativeTest.java b/java/test/auto_check_sbp_navigation_MsgPoseRelativeTest.java index a9cc77cbd..7232de084 100644 --- a/java/test/auto_check_sbp_navigation_MsgPoseRelativeTest.java +++ b/java/test/auto_check_sbp_navigation_MsgPoseRelativeTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPoseRelative.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgPoseRelative.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgPoseRelative; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgPoseRelativeTest { @@ -30,101 +34,9 @@ public class auto_check_sbp_navigation_MsgPoseRelativeTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgPoseRelativeTest.test1"); - byte[] payload = - new byte[] { - (byte) 86, - (byte) 4, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 86, - (byte) 4, - (byte) 0, - (byte) 0, - (byte) 172, - (byte) 8, - (byte) 0, - (byte) 0, - (byte) 76, - (byte) 4, - (byte) 0, - (byte) 0, - (byte) 38, - (byte) 2, - (byte) 0, - (byte) 0, - (byte) 100, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 100, - (byte) 3, - (byte) 200, - (byte) 204, - (byte) 252, - (byte) 168, - (byte) 157, - (byte) 255, - (byte) 115, - (byte) 53, - (byte) 186, - (byte) 144, - (byte) 190, - (byte) 48, - (byte) 34, - (byte) 37, - (byte) 0, - (byte) 0, - (byte) 128, - (byte) 63, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 128, - (byte) 63, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 128, - (byte) 63, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 64, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 64, - (byte) 5, - }; - SBPMessage sbp = new SBPMessage(0x42, 0x245, payload); - MsgPoseRelative msg = new MsgPoseRelative(sbp); + byte[] payload = new byte[] {(byte)86,(byte)4,(byte)0,(byte)0,(byte)0,(byte)86,(byte)4,(byte)0,(byte)0,(byte)172,(byte)8,(byte)0,(byte)0,(byte)76,(byte)4,(byte)0,(byte)0,(byte)38,(byte)2,(byte)0,(byte)0,(byte)100,(byte)0,(byte)0,(byte)0,(byte)100,(byte)3,(byte)200,(byte)204,(byte)252,(byte)168,(byte)157,(byte)255,(byte)115,(byte)53,(byte)186,(byte)144,(byte)190,(byte)48,(byte)34,(byte)37,(byte)0,(byte)0,(byte)128,(byte)63,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)63,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)63,(byte)0,(byte)0,(byte)0,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)64,(byte)5, }; + SBPMessage sbp = new SBPMessage( 0x42, 0x245, payload ); + MsgPoseRelative msg = new MsgPoseRelative( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; @@ -142,8 +54,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.cov_r_z_z, 1.00000000000000000e+00, DELTA); value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -151,8 +62,7 @@ public void test1() throws Throwable { } value = msg.sensor_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sensor_id + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sensor_id + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -160,9 +70,7 @@ public void test1() throws Throwable { } value = msg.timestamp_1; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.timestamp_1 + "' != '" + 1110 + "'", - value.equals(BigInteger.valueOf(1110L))); + org.junit.Assert.assertTrue("'" + msg.timestamp_1 + "' != '" + 1110 + "'", value.equals(BigInteger.valueOf( 1110L ) ) ); } else { value = value.longValue(); expected = 1110L; @@ -170,9 +78,7 @@ public void test1() throws Throwable { } value = msg.timestamp_2; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.timestamp_2 + "' != '" + 2220 + "'", - value.equals(BigInteger.valueOf(2220L))); + org.junit.Assert.assertTrue("'" + msg.timestamp_2 + "' != '" + 2220 + "'", value.equals(BigInteger.valueOf( 2220L ) ) ); } else { value = value.longValue(); expected = 2220L; @@ -180,8 +86,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 1110 + "'", value.equals(BigInteger.valueOf(1110L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 1110 + "'", value.equals(BigInteger.valueOf( 1110L ) ) ); } else { value = value.longValue(); expected = 1110L; @@ -189,9 +94,7 @@ public void test1() throws Throwable { } value = msg.trans[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.trans[0] + "' != '" + 1100 + "'", - value.equals(BigInteger.valueOf(1100L))); + org.junit.Assert.assertTrue("'" + msg.trans[0] + "' != '" + 1100 + "'", value.equals(BigInteger.valueOf( 1100L ) ) ); } else { value = value.longValue(); expected = 1100L; @@ -199,9 +102,7 @@ public void test1() throws Throwable { } value = msg.trans[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.trans[1] + "' != '" + 550 + "'", - value.equals(BigInteger.valueOf(550L))); + org.junit.Assert.assertTrue("'" + msg.trans[1] + "' != '" + 550 + "'", value.equals(BigInteger.valueOf( 550L ) ) ); } else { value = value.longValue(); expected = 550L; @@ -209,9 +110,7 @@ public void test1() throws Throwable { } value = msg.trans[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.trans[2] + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.trans[2] + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -219,9 +118,7 @@ public void test1() throws Throwable { } value = msg.w; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.w + "' != '" + -859307164 + "'", - value.equals(BigInteger.valueOf(-859307164L))); + org.junit.Assert.assertTrue("'" + msg.w + "' != '" + -859307164 + "'", value.equals(BigInteger.valueOf( -859307164L ) ) ); } else { value = value.longValue(); expected = -859307164L; @@ -229,9 +126,7 @@ public void test1() throws Throwable { } value = msg.x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.x + "' != '" + -6444804 + "'", - value.equals(BigInteger.valueOf(-6444804L))); + org.junit.Assert.assertTrue("'" + msg.x + "' != '" + -6444804 + "'", value.equals(BigInteger.valueOf( -6444804L ) ) ); } else { value = value.longValue(); expected = -6444804L; @@ -239,9 +134,7 @@ public void test1() throws Throwable { } value = msg.y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.y + "' != '" + -1866844813 + "'", - value.equals(BigInteger.valueOf(-1866844813L))); + org.junit.Assert.assertTrue("'" + msg.y + "' != '" + -1866844813 + "'", value.equals(BigInteger.valueOf( -1866844813L ) ) ); } else { value = value.longValue(); expected = -1866844813L; @@ -249,9 +142,7 @@ public void test1() throws Throwable { } value = msg.z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.z + "' != '" + 622997694 + "'", - value.equals(BigInteger.valueOf(622997694L))); + org.junit.Assert.assertTrue("'" + msg.z + "' != '" + 622997694 + "'", value.equals(BigInteger.valueOf( 622997694L ) ) ); } else { value = value.longValue(); expected = 622997694L; diff --git a/java/test/auto_check_sbp_navigation_MsgProtectionLevelDepATest.java b/java/test/auto_check_sbp_navigation_MsgProtectionLevelDepATest.java index ceb164325..aaafec0c8 100644 --- a/java/test/auto_check_sbp_navigation_MsgProtectionLevelDepATest.java +++ b/java/test/auto_check_sbp_navigation_MsgProtectionLevelDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgProtectionLevelDepA.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgProtectionLevelDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgProtectionLevelDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgProtectionLevelDepATest { @@ -29,53 +33,16 @@ public class auto_check_sbp_navigation_MsgProtectionLevelDepATest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_navigation_MsgProtectionLevelDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 52, - (byte) 126, - (byte) 69, - (byte) 185, - (byte) 47, - (byte) 85, - (byte) 4, - (byte) 139, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 244, - (byte) 190, - (byte) 64, - (byte) 102, - (byte) 102, - (byte) 102, - (byte) 102, - (byte) 102, - (byte) 204, - (byte) 168, - (byte) 64, - (byte) 154, - (byte) 153, - (byte) 153, - (byte) 153, - (byte) 25, - (byte) 39, - (byte) 192, - (byte) 64, - (byte) 248, - }; - SBPMessage sbp = new SBPMessage(0x1694, 0x216, payload); - MsgProtectionLevelDepA msg = new MsgProtectionLevelDepA(sbp); + System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgProtectionLevelDepATest.test1"); + byte[] payload = new byte[] {(byte)52,(byte)126,(byte)69,(byte)185,(byte)47,(byte)85,(byte)4,(byte)139,(byte)51,(byte)51,(byte)51,(byte)51,(byte)51,(byte)244,(byte)190,(byte)64,(byte)102,(byte)102,(byte)102,(byte)102,(byte)102,(byte)204,(byte)168,(byte)64,(byte)154,(byte)153,(byte)153,(byte)153,(byte)25,(byte)39,(byte)192,(byte)64,(byte)248, }; + SBPMessage sbp = new SBPMessage( 0x1694, 0x216, payload ); + MsgProtectionLevelDepA msg = new MsgProtectionLevelDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 248 + "'", value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -84,9 +51,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.height, 8.27020000000000073e+03, DELTA); value = msg.hpl; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hpl + "' != '" + 35588 + "'", - value.equals(BigInteger.valueOf(35588L))); + org.junit.Assert.assertTrue("'" + msg.hpl + "' != '" + 35588 + "'", value.equals(BigInteger.valueOf( 35588L ) ) ); } else { value = value.longValue(); expected = 35588L; @@ -96,9 +61,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.lon, 3.17419999999999982e+03, DELTA); value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 3108339252L + "'", - value.equals(new BigInteger("3108339252"))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 3108339252L + "'", value.equals( new BigInteger( "3108339252" ) ) ); } else { value = value.longValue(); expected = 3108339252L; @@ -106,9 +69,7 @@ public void test1() throws Throwable { } value = msg.vpl; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vpl + "' != '" + 21807 + "'", - value.equals(BigInteger.valueOf(21807L))); + org.junit.Assert.assertTrue("'" + msg.vpl + "' != '" + 21807 + "'", value.equals(BigInteger.valueOf( 21807L ) ) ); } else { value = value.longValue(); expected = 21807L; diff --git a/java/test/auto_check_sbp_navigation_MsgProtectionLevelTest.java b/java/test/auto_check_sbp_navigation_MsgProtectionLevelTest.java index 1d0c2a96e..3ec37c9c7 100644 --- a/java/test/auto_check_sbp_navigation_MsgProtectionLevelTest.java +++ b/java/test/auto_check_sbp_navigation_MsgProtectionLevelTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/navigation/test_MsgProtectionLevel.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/navigation/test_MsgProtectionLevel.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.navigation.MsgProtectionLevel; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_navigation_MsgProtectionLevelTest { @@ -30,95 +34,15 @@ public class auto_check_sbp_navigation_MsgProtectionLevelTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_navigation_MsgProtectionLevelTest.test1"); - byte[] payload = - new byte[] { - (byte) 110, - (byte) 84, - (byte) 4, - (byte) 242, - (byte) 46, - (byte) 51, - (byte) 53, - (byte) 160, - (byte) 89, - (byte) 84, - (byte) 167, - (byte) 41, - (byte) 57, - (byte) 21, - (byte) 217, - (byte) 244, - (byte) 61, - (byte) 161, - (byte) 83, - (byte) 104, - (byte) 140, - (byte) 137, - (byte) 90, - (byte) 246, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 170, - (byte) 180, - (byte) 64, - (byte) 154, - (byte) 153, - (byte) 153, - (byte) 153, - (byte) 25, - (byte) 88, - (byte) 195, - (byte) 64, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 51, - (byte) 195, - (byte) 121, - (byte) 64, - (byte) 231, - (byte) 251, - (byte) 38, - (byte) 221, - (byte) 208, - (byte) 183, - (byte) 167, - (byte) 80, - (byte) 223, - (byte) 26, - (byte) 97, - (byte) 164, - (byte) 45, - (byte) 46, - (byte) 186, - (byte) 60, - (byte) 235, - (byte) 227, - (byte) 183, - (byte) 160, - (byte) 187, - (byte) 93, - (byte) 116, - (byte) 224, - (byte) 105, - (byte) 40, - (byte) 32, - (byte) 33, - }; - SBPMessage sbp = new SBPMessage(0x032d, 0x217, payload); - MsgProtectionLevel msg = new MsgProtectionLevel(sbp); + byte[] payload = new byte[] {(byte)110,(byte)84,(byte)4,(byte)242,(byte)46,(byte)51,(byte)53,(byte)160,(byte)89,(byte)84,(byte)167,(byte)41,(byte)57,(byte)21,(byte)217,(byte)244,(byte)61,(byte)161,(byte)83,(byte)104,(byte)140,(byte)137,(byte)90,(byte)246,(byte)51,(byte)51,(byte)51,(byte)51,(byte)51,(byte)170,(byte)180,(byte)64,(byte)154,(byte)153,(byte)153,(byte)153,(byte)25,(byte)88,(byte)195,(byte)64,(byte)51,(byte)51,(byte)51,(byte)51,(byte)51,(byte)195,(byte)121,(byte)64,(byte)231,(byte)251,(byte)38,(byte)221,(byte)208,(byte)183,(byte)167,(byte)80,(byte)223,(byte)26,(byte)97,(byte)164,(byte)45,(byte)46,(byte)186,(byte)60,(byte)235,(byte)227,(byte)183,(byte)160,(byte)187,(byte)93,(byte)116,(byte)224,(byte)105,(byte)40,(byte)32,(byte)33, }; + SBPMessage sbp = new SBPMessage( 0x032d, 0x217, payload ); + MsgProtectionLevel msg = new MsgProtectionLevel( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.atpl; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.atpl + "' != '" + 10663 + "'", - value.equals(BigInteger.valueOf(10663L))); + org.junit.Assert.assertTrue("'" + msg.atpl + "' != '" + 10663 + "'", value.equals(BigInteger.valueOf( 10663L ) ) ); } else { value = value.longValue(); expected = 10663L; @@ -126,9 +50,7 @@ public void test1() throws Throwable { } value = msg.ctpl; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ctpl + "' != '" + 5433 + "'", - value.equals(BigInteger.valueOf(5433L))); + org.junit.Assert.assertTrue("'" + msg.ctpl + "' != '" + 5433 + "'", value.equals(BigInteger.valueOf( 5433L ) ) ); } else { value = value.longValue(); expected = 5433L; @@ -136,9 +58,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 555755625 + "'", - value.equals(BigInteger.valueOf(555755625L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 555755625 + "'", value.equals(BigInteger.valueOf( 555755625L ) ) ); } else { value = value.longValue(); expected = 555755625L; @@ -146,9 +66,7 @@ public void test1() throws Throwable { } value = msg.heading; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.heading + "' != '" + -529244741 + "'", - value.equals(BigInteger.valueOf(-529244741L))); + org.junit.Assert.assertTrue("'" + msg.heading + "' != '" + -529244741 + "'", value.equals(BigInteger.valueOf( -529244741L ) ) ); } else { value = value.longValue(); expected = -529244741L; @@ -157,9 +75,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.height, 4.12199999999999989e+02, DELTA); value = msg.hopl; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hopl + "' != '" + 26707 + "'", - value.equals(BigInteger.valueOf(26707L))); + org.junit.Assert.assertTrue("'" + msg.hopl + "' != '" + 26707 + "'", value.equals(BigInteger.valueOf( 26707L ) ) ); } else { value = value.longValue(); expected = 26707L; @@ -167,9 +83,7 @@ public void test1() throws Throwable { } value = msg.hpl; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hpl + "' != '" + 41013 + "'", - value.equals(BigInteger.valueOf(41013L))); + org.junit.Assert.assertTrue("'" + msg.hpl + "' != '" + 41013 + "'", value.equals(BigInteger.valueOf( 41013L ) ) ); } else { value = value.longValue(); expected = 41013L; @@ -177,9 +91,7 @@ public void test1() throws Throwable { } value = msg.hvpl; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hvpl + "' != '" + 62681 + "'", - value.equals(BigInteger.valueOf(62681L))); + org.junit.Assert.assertTrue("'" + msg.hvpl + "' != '" + 62681 + "'", value.equals(BigInteger.valueOf( 62681L ) ) ); } else { value = value.longValue(); expected = 62681L; @@ -189,9 +101,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.lon, 9.90420000000000073e+03, DELTA); value = msg.pitch; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pitch + "' != '" + -1598561301 + "'", - value.equals(BigInteger.valueOf(-1598561301L))); + org.junit.Assert.assertTrue("'" + msg.pitch + "' != '" + -1598561301 + "'", value.equals(BigInteger.valueOf( -1598561301L ) ) ); } else { value = value.longValue(); expected = -1598561301L; @@ -199,9 +109,7 @@ public void test1() throws Throwable { } value = msg.popl; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.popl + "' != '" + 35212 + "'", - value.equals(BigInteger.valueOf(35212L))); + org.junit.Assert.assertTrue("'" + msg.popl + "' != '" + 35212 + "'", value.equals(BigInteger.valueOf( 35212L ) ) ); } else { value = value.longValue(); expected = 35212L; @@ -209,9 +117,7 @@ public void test1() throws Throwable { } value = msg.roll; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.roll + "' != '" + 1018834477 + "'", - value.equals(BigInteger.valueOf(1018834477L))); + org.junit.Assert.assertTrue("'" + msg.roll + "' != '" + 1018834477 + "'", value.equals(BigInteger.valueOf( 1018834477L ) ) ); } else { value = value.longValue(); expected = 1018834477L; @@ -219,9 +125,7 @@ public void test1() throws Throwable { } value = msg.ropl; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ropl + "' != '" + 63066 + "'", - value.equals(BigInteger.valueOf(63066L))); + org.junit.Assert.assertTrue("'" + msg.ropl + "' != '" + 63066 + "'", value.equals(BigInteger.valueOf( 63066L ) ) ); } else { value = value.longValue(); expected = 63066L; @@ -229,9 +133,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 4060370030L + "'", - value.equals(new BigInteger("4060370030"))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 4060370030L + "'", value.equals( new BigInteger( "4060370030" ) ) ); } else { value = value.longValue(); expected = 4060370030L; @@ -239,9 +141,7 @@ public void test1() throws Throwable { } value = msg.v_x; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_x + "' != '" + -584647705 + "'", - value.equals(BigInteger.valueOf(-584647705L))); + org.junit.Assert.assertTrue("'" + msg.v_x + "' != '" + -584647705 + "'", value.equals(BigInteger.valueOf( -584647705L ) ) ); } else { value = value.longValue(); expected = -584647705L; @@ -249,9 +149,7 @@ public void test1() throws Throwable { } value = msg.v_y; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_y + "' != '" + 1353168848 + "'", - value.equals(BigInteger.valueOf(1353168848L))); + org.junit.Assert.assertTrue("'" + msg.v_y + "' != '" + 1353168848 + "'", value.equals(BigInteger.valueOf( 1353168848L ) ) ); } else { value = value.longValue(); expected = 1353168848L; @@ -259,9 +157,7 @@ public void test1() throws Throwable { } value = msg.v_z; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.v_z + "' != '" + -1537140001 + "'", - value.equals(BigInteger.valueOf(-1537140001L))); + org.junit.Assert.assertTrue("'" + msg.v_z + "' != '" + -1537140001 + "'", value.equals(BigInteger.valueOf( -1537140001L ) ) ); } else { value = value.longValue(); expected = -1537140001L; @@ -269,9 +165,7 @@ public void test1() throws Throwable { } value = msg.vpl; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vpl + "' != '" + 21593 + "'", - value.equals(BigInteger.valueOf(21593L))); + org.junit.Assert.assertTrue("'" + msg.vpl + "' != '" + 21593 + "'", value.equals(BigInteger.valueOf( 21593L ) ) ); } else { value = value.longValue(); expected = 21593L; @@ -279,9 +173,7 @@ public void test1() throws Throwable { } value = msg.vvpl; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vvpl + "' != '" + 41277 + "'", - value.equals(BigInteger.valueOf(41277L))); + org.junit.Assert.assertTrue("'" + msg.vvpl + "' != '" + 41277 + "'", value.equals(BigInteger.valueOf( 41277L ) ) ); } else { value = value.longValue(); expected = 41277L; @@ -289,9 +181,7 @@ public void test1() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 13102 + "'", - value.equals(BigInteger.valueOf(13102L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 13102 + "'", value.equals(BigInteger.valueOf( 13102L ) ) ); } else { value = value.longValue(); expected = 13102L; diff --git a/java/test/auto_check_sbp_navigation_MsgReferenceFrameParamTest.java b/java/test/auto_check_sbp_navigation_MsgReferenceFrameParamTest.java index 845a5765e7a31afd86c683a78179058cef25978a..69fa519ceaf9a0b3200f52e4510499a7d43f9a7e 100644 GIT binary patch literal 9054 zcmd^FZExC05bkGw#T2Ou^r&IUdry^)fOGL3F$hT8^mIbTEa235Iq#YjRr&8XYiw-X zkhoHo4|hb$+Uwb8cAlM`881}d7T_&3*<$58)0u!$vkdhbIeu5K)d}?PorwU`S~^op zILrgXv$gdAPgu5i4>KVa{C%~`gT;dRLgR9TXDv0G%~4Rw4rUGq&H~@2Ag_Ya9km4r z24Y6Rb!_T!3KJH1V{p8%bK}|@mC=W0r=>%~Y=L23c6!&1fzdGm`@6l) zN28^;pxEf+eGxtxgR9QX06sN(y@olsh0Z08yM;duvsICBItu7L&_8#3dcTh&J3TP2 zyKO^nRS><|zG)fe?{I+_W@i9xEw z!xMB$eVlXjl=)NbF7OhIdb%bP-3I@xOq6X zun0!z&S1M1U(-0WXVm^WM3ROHzz%+-3Gls80Q^KiT;Q&=VZ@kAEf2h@|BspoA9V#yrbLfA=4W!yYIyXWW* z*jN(cdnhUgIuj^``pcUx+1+1pLFXC^gf?M5E>x-b#(Trxc*P17r6c_;1EE)vVtH+z zR54l!`q$sEuvRX!#%Pa6@8izzCHb^WDp6aj$5&+2x4EiC&;IM}`B`M>`RRs@qyLHR z@!H1r9%t-6$=t^b#pAMVOl7t|zCX|4#r<(h;)`AFv))N!m)?nR_}m;~GIkj!5zxll4R=JS5Q}3EqHFHi`~OX9;TGYPF+!MYi>$qsk_Zq$14Y0UhRC z23r|z9v3Ku8dEq)wt+j$J~$X5G{IzlDJ5qH^AXl7OUn(SFfQX<)Jwl%s>QsUm>9}M zU}NeEYxudAJe7fYE#Y{W1u*5Z2_(s~oQmO6OOi4h9BUz=VXDGr;0Lr+JSf61;hbYN zcw0Px*B>B!avI)ZWDoUe^q&9|Q7O@-h5emL2~OKkmVe1KAAn-g%1kDnqKZ~9Sk zlIBXzIi>_TIBh48Pne^xrxxN?HsjON*<`VJ4sxm1X5a3I-P_tWyJxxCJyXT**&f*a zvLAN8WY|5=&F;A>cF)za%fv9=w#gn*6CF~jwtbi!<))b&sp1)t69Noa86^L>bX1%8BN-<)(@eWpN|av+c|Eb*Ro$SJZ2& zC`M$}K?4t>uy(7FM2|9-V^!Nkll%o7QC7hrazcQb=p0#JPxPoJx}G6Ae=SFp6?2H3 z5TKOk!$gm2q7O4f=P&DsvbqkD69QhIXrB&+>Y6#!u}y9Myr(Sfsm*%($as%rJF<4+ zJlT#Ms>*hVtkPw<<0bG)LIP^ocGvtb9?IT3UjDUX$6-x$x*<<2xQFNL6UJUW^(m$g zV$$awoclwErH-1^tkqh}_Ii=mO!h&r>gp~cI9u7ROX^$!qOOeK`im3%d`K5Eq>n8Bsfhk+XGjl( z>eP!Gw)aB*qbOx3Q7?B8wfSCP$3mG*MCrGPz9~~M{`%z7cc?dZS0?_}p;V5(W_Tz( G6#fPNkRl=g literal 12333 zcmeHNZFAZ<5bkGw#g>^);4U@Dd2gpPN5HxIjsOFsZF+OV7$d-`u{cX6Wjguqw=x(5 z4JO4g{t|x(v9vGJKD(>cLg6lm215b4avszoIeDuVRTWzIR$oBPm{1K181IVQjq_7-8*Uu5DdhS zf^C`9;S~DJb9!Jo{$Ss-DI8SwvQ}$p2XH^M%pr_CE~LCJg`UNQYjr(Adnji>QIHGw zmKY-ULYV?3+Xm*(`J3b5Qcm3o?a4j(OZ%v|pj@wLP^wixuU*xf*QK^zuK|uXn)Oe5 zMXNxz)WY{HeAe3^>o;xqTxvE;we~I4uaNH+{?==iLn%%}0<8(!mqt@-wUD#k1pT^E z)wRkYN-tM$DthftxI`JXdK;?xwcbXmb{&u}pp=5<8g#8CbzE!B@<&uyy40&Ws>QVy zQ1X@DuAv&hMMDW1rDj_%-&9LYXxua#^_C_#S;&kH^P4fCfOv%9@a|XGbq#6WzKcL25g${tAbEIUYK-hc0CWLm6%g>bhxjC&Yd&bwK6R;M z(ks^((T0J470C$QDFo7$@l=5d1BVHzV#In@e<}%vhSPhU$z-gNbgG}%-nwjDQ_gW; z?>EwfYf>Ix&Vu#Mm>9~)5JTnC8t9Io1L`g&nLAMKICGT0TJ>7pciq)F&#{Eko*8rO zb@0delaA6TT?FRNMW8(`piWm=2oU9iF~qeoHzW9lRbp2^siqvi|?!? zo1g7j3hYh={pVj88&jJZJ^1jGR)^jPMByeRXYk~th&&LC+(({Zwx~wWlP&yP=8KWi zUuJz|=2*N~7ElEgC{W}^fU%< zbmmA7-{^#voZgEVwu-YV5{EesZ))`$i7q_j>?xX;9HoVEbcjcpO21MqxSF-oRE8>qFR~$uBi0q!zzX<2PeU9J_o%!5$2Lv|W#G z=t&%8;dg%{fo^=w9>D7l;Ln`-uh_Ei7opJqJZ!ty=ZTp6d=KXSnxeVCu9^Gdsph^&#M~FjnwyDE5Y%B5?J=P&>0kA7ay+;DA}VEU z2hS`!Y|b>~I1w;VY-lC9mJPXd*Icu(MoRf+N&gxeC$Z2tNd}FRJ)x0OI$EHyo|4FE zEHqA&LE|)WG`MNlOXbpj)0D4#H7eBEQIUQ89=I(>sl`NaK(R^ZDEy`vOVA<-_3Rgl zK>sQlB&b7oJ28?ePD#SmDdvc|HPn>RP}k51%GBM^NTzlr2^X&+8b>LkakPd;P{rNw&6iX-A}TkMI?*+CMn3w_cHxIh&I`no~QLA32iA%<-Slj37se9KR?w4E^W7 zB5=zI#qaObMYXFA9o){gI&?A@vFE>sMc?FPCx|=vqntitucDsipWZCDkvMld7F%lR z?Gd|~>Q(%R|N4|LNhV4X4U(WfOe0bP-D~EKbyFb8+!Ro3Xrbp%RcY3xf$lXF0Qi^$K~Z&l|!FG0>Tu z$)O{zU{H}{k(j6hrganw5-W4^6H^o>ui`LdRVYp>P?&s=V-=&qURX8@ufj(7k7 literal 2935 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 literal 23918 zcmeHPZExC05bkGw#T2Ou+@;2A-g~NaB#^7`2t+{It4^oLm<8N|P5qJ-Rr&8XYcMzo ztm$Dp5ZNDsiwS?_W=%bCp#(-tg7p)0q7YD}>rtJ@oE7FdR3sub9r)Bi$M z8*BsYF@=eyQr)63G#q^Zn(jUvY7+`4P5Hdh>NZZ`Zmg+em^zlt`1L6aG|M)%zGKq? z@)=QNWWt?hkCA#MOn};C0)|`WcFqEmTGYIy1J(z(X&>Y+oVV)@sI}@Kw=UY9%UVxv zw*a4Cb=n{0dZP~MS{MIM!za1-p?%$hPqj{`*6MwR_65>?hQH)i{gkn5V1-5p8h>AP z8r?2ZwmTqSUNz-L{S>*MH?Qk*>kl|X9<6o{n)0RG!&<#IAe~o}FOz0cWOxjP*<66S0lHzs)EH>PIaYwNq7PoDQYmf92GP^D zcF(RZsbyh5e%o5dZHDl$1*_U$lv_oZD)v}7(?+sx(-AdSg@!p2zF3AX{Ml`{+V1Fl zSmx-OE%X-pnmK(OvY<{BYoV(fbxhT-H>imlw+WAwz{uc7Dg}5gX)RO^vgjMegep1= zXx|yZdl)Jc3;X9*G__k)AS`PRHC>s&z(COy>WyZvhSdpuONwYfR{wV<#V_L4&~Rqp zLz2njoG^_$3(br_3S;rZt;z_sA!JwqOLOOH~Jgvjh;S*G#eB< zbkrSGB%NLKf(hu)ZTio@FjM9eLm9yPm1I`PE}hg_rv5IqS!?i50 zmbt}5Eb_~V$SqGwUDYp@ooK_a4N@#|#}0qs{%zCgb@=%h1i*@FALJ&wwsjEM`Bf% zaae|3b#04fTZX+fZW@O%vlhbT3sa-|U@~u^tux-Zy$`|?Qv6s#@(;NXu|xnE5cy7- zh!w8GCnDjN^SLLb?hHL*s8Pvt%`b6F^L#K7^5{swM0{YPSS{`fC$MTHp@;DeEAn`8 zbW7lQ3MsU~gg!zPul)Y~@F7LMv^3x<>Uv6Gzd?W^Uy8)0$TlpKuDZ3wrXhlfeEeV{ z?;mWTfr&C73zYa!qr&&+d48-Y^8-yl9IEh{^IMjbx>G-LltKzzw7@q5A$%~g5AO|< z6EG1Um>`8+u>>hZ5_XVnSYgKtqFbWQQzX%hM#xC*OkOC<{ObuyP-5$o``RG zqP#1lC`S@}%FhQWri#w;Efw|K8d>=L`{6?hDKB}8ORE=n4_UF_pnVQTABk06#zzP# zO7TOAl7Gk@45UbsFui${thjiZV80<~gB1AtaL6y%E3jHpffI!7NJq zq)bSKq7)63V2qCtN|fV=66J`X1V1r?BsrL#zX&BhZg?LKDe@jBXG!AY0sdad0ViQ5 zU}B#G9fgYbY8&_(i&Y~DJ&bQyk;iipJ41>j2Qw0z9%l|_C4Mkbi3Cg}IhdX!c+oNa zxsV3Q?}H_({50Er_D?n_Su3Y%_!j(Zb z^o@T&fJhril9=RvRb{cw8~XU*zg4;^cAGae!K8eB@$pEVZ%Z*Y@ER2IXP*!@x!DI*v(I%#j!$*osmT}z~cFFg>B-;6TL+X|GVQc a92Cg!m))1oN0i;i7>5NI!^9Q$ss8|lET~uj diff --git a/java/test/auto_check_sbp_piksi_MsgUartStateDepATest.java b/java/test/auto_check_sbp_piksi_MsgUartStateDepATest.java index 3dcabe9e6..a0aafa965 100644 --- a/java/test/auto_check_sbp_piksi_MsgUartStateDepATest.java +++ b/java/test/auto_check_sbp_piksi_MsgUartStateDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/piksi/test_MsgUartStateDepA.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/piksi/test_MsgUartStateDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.piksi.MsgUartStateDepa; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_piksi_MsgUartStateDepATest { @@ -27,78 +32,17 @@ public class auto_check_sbp_piksi_MsgUartStateDepATest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 154, - (byte) 153, - (byte) 57, - (byte) 65, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 15, - (byte) 0, - (byte) 255, - (byte) 255, - (byte) 255, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 255, - (byte) 255, - (byte) 255, - (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x18, payload); - MsgUartStateDepa msg = new MsgUartStateDepa(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateDepATest.test1"); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)154,(byte)153,(byte)57,(byte)65,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)15,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x18, payload ); + MsgUartStateDepa msg = new MsgUartStateDepa( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.latency.avg; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.avg + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.avg + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -106,9 +50,7 @@ public void test1() throws Throwable { } value = msg.latency.current; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.current + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.current + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -116,9 +58,7 @@ public void test1() throws Throwable { } value = msg.latency.lmax; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmax + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmax + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -126,9 +66,7 @@ public void test1() throws Throwable { } value = msg.latency.lmin; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmin + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmin + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -136,9 +74,7 @@ public void test1() throws Throwable { } value = msg.uart_a.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -146,9 +82,7 @@ public void test1() throws Throwable { } value = msg.uart_a.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -156,9 +90,7 @@ public void test1() throws Throwable { } value = msg.uart_a.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -167,9 +99,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_a.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.tx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.tx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -178,9 +108,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.tx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -188,9 +116,7 @@ public void test1() throws Throwable { } value = msg.uart_b.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -198,9 +124,7 @@ public void test1() throws Throwable { } value = msg.uart_b.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -209,9 +133,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.tx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.tx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -220,9 +142,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.tx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_ftdi.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -230,9 +150,7 @@ public void test1() throws Throwable { } value = msg.uart_ftdi.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -240,9 +158,7 @@ public void test1() throws Throwable { } value = msg.uart_ftdi.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -251,9 +167,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.uart_ftdi.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_ftdi.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -266,78 +180,17 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateDepATest.test2"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 2, - (byte) 43, - (byte) 135, - (byte) 61, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 255, - (byte) 255, - (byte) 255, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 255, - (byte) 255, - (byte) 255, - (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x18, payload); - MsgUartStateDepa msg = new MsgUartStateDepa(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateDepATest.test2"); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)2,(byte)43,(byte)135,(byte)61,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x18, payload ); + MsgUartStateDepa msg = new MsgUartStateDepa( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.latency.avg; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.avg + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.avg + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -345,9 +198,7 @@ public void test2() throws Throwable { } value = msg.latency.current; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.current + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.current + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -355,9 +206,7 @@ public void test2() throws Throwable { } value = msg.latency.lmax; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmax + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmax + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -365,9 +214,7 @@ public void test2() throws Throwable { } value = msg.latency.lmin; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmin + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmin + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -375,9 +222,7 @@ public void test2() throws Throwable { } value = msg.uart_a.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -385,9 +230,7 @@ public void test2() throws Throwable { } value = msg.uart_a.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -395,9 +238,7 @@ public void test2() throws Throwable { } value = msg.uart_a.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -406,9 +247,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_a.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.tx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.tx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -417,9 +256,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.tx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -427,9 +264,7 @@ public void test2() throws Throwable { } value = msg.uart_b.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -437,9 +272,7 @@ public void test2() throws Throwable { } value = msg.uart_b.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -448,9 +281,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.tx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.tx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -459,9 +290,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.tx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_ftdi.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -469,9 +298,7 @@ public void test2() throws Throwable { } value = msg.uart_ftdi.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -479,9 +306,7 @@ public void test2() throws Throwable { } value = msg.uart_ftdi.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -490,9 +315,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.uart_ftdi.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_ftdi.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -505,78 +328,17 @@ public void test2() throws Throwable { @Test public void test3() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateDepATest.test3"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 4, - (byte) 86, - (byte) 14, - (byte) 62, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 10, - (byte) 0, - (byte) 255, - (byte) 255, - (byte) 255, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 255, - (byte) 255, - (byte) 255, - (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x18, payload); - MsgUartStateDepa msg = new MsgUartStateDepa(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateDepATest.test3"); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)4,(byte)86,(byte)14,(byte)62,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)10,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x18, payload ); + MsgUartStateDepa msg = new MsgUartStateDepa( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.latency.avg; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.avg + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.avg + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -584,9 +346,7 @@ public void test3() throws Throwable { } value = msg.latency.current; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.current + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.current + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -594,9 +354,7 @@ public void test3() throws Throwable { } value = msg.latency.lmax; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmax + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmax + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -604,9 +362,7 @@ public void test3() throws Throwable { } value = msg.latency.lmin; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmin + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmin + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -614,9 +370,7 @@ public void test3() throws Throwable { } value = msg.uart_a.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -624,9 +378,7 @@ public void test3() throws Throwable { } value = msg.uart_a.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -634,9 +386,7 @@ public void test3() throws Throwable { } value = msg.uart_a.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -645,9 +395,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_a.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.tx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.tx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -656,9 +404,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.tx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -666,9 +412,7 @@ public void test3() throws Throwable { } value = msg.uart_b.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -676,9 +420,7 @@ public void test3() throws Throwable { } value = msg.uart_b.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -687,9 +429,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.tx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.tx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -698,9 +438,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.tx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_ftdi.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -708,9 +446,7 @@ public void test3() throws Throwable { } value = msg.uart_ftdi.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -718,9 +454,7 @@ public void test3() throws Throwable { } value = msg.uart_ftdi.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -729,9 +463,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.uart_ftdi.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_ftdi.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -744,78 +476,17 @@ public void test3() throws Throwable { @Test public void test4() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateDepATest.test4"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 2, - (byte) 43, - (byte) 135, - (byte) 61, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 255, - (byte) 255, - (byte) 255, - (byte) 255, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 255, - (byte) 255, - (byte) 255, - (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x18, payload); - MsgUartStateDepa msg = new MsgUartStateDepa(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateDepATest.test4"); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)2,(byte)43,(byte)135,(byte)61,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x18, payload ); + MsgUartStateDepa msg = new MsgUartStateDepa( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.latency.avg; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.avg + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.avg + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -823,9 +494,7 @@ public void test4() throws Throwable { } value = msg.latency.current; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.current + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.current + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -833,9 +502,7 @@ public void test4() throws Throwable { } value = msg.latency.lmax; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmax + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmax + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -843,9 +510,7 @@ public void test4() throws Throwable { } value = msg.latency.lmin; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmin + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmin + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -853,9 +518,7 @@ public void test4() throws Throwable { } value = msg.uart_a.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -863,9 +526,7 @@ public void test4() throws Throwable { } value = msg.uart_a.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -873,9 +534,7 @@ public void test4() throws Throwable { } value = msg.uart_a.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -884,9 +543,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_a.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.tx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.tx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -895,9 +552,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.tx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -905,9 +560,7 @@ public void test4() throws Throwable { } value = msg.uart_b.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -915,9 +568,7 @@ public void test4() throws Throwable { } value = msg.uart_b.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -926,9 +577,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.tx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.tx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -937,9 +586,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.tx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_ftdi.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -947,9 +594,7 @@ public void test4() throws Throwable { } value = msg.uart_ftdi.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -957,9 +602,7 @@ public void test4() throws Throwable { } value = msg.uart_ftdi.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -968,9 +611,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.uart_ftdi.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_ftdi.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -983,29 +624,17 @@ public void test4() throws Throwable { @Test public void test5() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateDepATest.test5"); - byte[] payload = - new byte[] { - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 138, (byte) 75, (byte) 6, - (byte) 60, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, - (byte) 80, (byte) 113, (byte) 201, (byte) 61, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 2, (byte) 0, - (byte) 145, (byte) 237, (byte) 252, (byte) 62, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 38, (byte) 0, - (byte) 255, (byte) 255, (byte) 255, (byte) 255, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 255, (byte) 255, - (byte) 255, (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x18, payload); - MsgUartStateDepa msg = new MsgUartStateDepa(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateDepATest.test5"); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)0,(byte)0,(byte)138,(byte)75,(byte)6,(byte)60,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)80,(byte)113,(byte)201,(byte)61,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)2,(byte)0,(byte)145,(byte)237,(byte)252,(byte)62,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)38,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x18, payload ); + MsgUartStateDepa msg = new MsgUartStateDepa( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.latency.avg; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.avg + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.avg + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -1013,9 +642,7 @@ public void test5() throws Throwable { } value = msg.latency.current; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.current + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.current + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -1023,9 +650,7 @@ public void test5() throws Throwable { } value = msg.latency.lmax; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmax + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmax + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1033,9 +658,7 @@ public void test5() throws Throwable { } value = msg.latency.lmin; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmin + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmin + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1043,9 +666,7 @@ public void test5() throws Throwable { } value = msg.uart_a.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1053,9 +674,7 @@ public void test5() throws Throwable { } value = msg.uart_a.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1063,9 +682,7 @@ public void test5() throws Throwable { } value = msg.uart_a.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1074,9 +691,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.rx_throughput, 8.19672085344791412e-03, DELTA); value = msg.uart_a.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.tx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.tx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1085,9 +700,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.tx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1095,9 +708,7 @@ public void test5() throws Throwable { } value = msg.uart_b.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1105,9 +716,7 @@ public void test5() throws Throwable { } value = msg.uart_b.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1116,9 +725,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.tx_buffer_level + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.tx_buffer_level + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1127,9 +734,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.tx_throughput, 9.83606576919555664e-02, DELTA); value = msg.uart_ftdi.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1137,9 +742,7 @@ public void test5() throws Throwable { } value = msg.uart_ftdi.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1147,9 +750,7 @@ public void test5() throws Throwable { } value = msg.uart_ftdi.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1158,9 +759,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.uart_ftdi.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_ftdi.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -1173,29 +772,17 @@ public void test5() throws Throwable { @Test public void test6() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateDepATest.test6"); - byte[] payload = - new byte[] { - (byte) 166, (byte) 155, (byte) 68, (byte) 60, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 2, (byte) 0, - (byte) 166, (byte) 155, (byte) 68, (byte) 60, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 2, (byte) 0, - (byte) 236, (byte) 81, (byte) 168, (byte) 63, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 50, (byte) 0, - (byte) 255, (byte) 255, (byte) 255, (byte) 255, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 255, (byte) 255, - (byte) 255, (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x18, payload); - MsgUartStateDepa msg = new MsgUartStateDepa(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateDepATest.test6"); + byte[] payload = new byte[] {(byte)166,(byte)155,(byte)68,(byte)60,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)2,(byte)0,(byte)166,(byte)155,(byte)68,(byte)60,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)2,(byte)0,(byte)236,(byte)81,(byte)168,(byte)63,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)50,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x18, payload ); + MsgUartStateDepa msg = new MsgUartStateDepa( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.latency.avg; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.avg + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.avg + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -1203,9 +790,7 @@ public void test6() throws Throwable { } value = msg.latency.current; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.current + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.current + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -1213,9 +798,7 @@ public void test6() throws Throwable { } value = msg.latency.lmax; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmax + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmax + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1223,9 +806,7 @@ public void test6() throws Throwable { } value = msg.latency.lmin; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmin + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmin + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1233,9 +814,7 @@ public void test6() throws Throwable { } value = msg.uart_a.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1243,9 +822,7 @@ public void test6() throws Throwable { } value = msg.uart_a.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1253,9 +830,7 @@ public void test6() throws Throwable { } value = msg.uart_a.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1264,9 +839,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_a.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.tx_buffer_level + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.tx_buffer_level + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1275,9 +848,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.tx_throughput, 1.20000001043081284e-02, DELTA); value = msg.uart_b.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1285,9 +856,7 @@ public void test6() throws Throwable { } value = msg.uart_b.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1295,9 +864,7 @@ public void test6() throws Throwable { } value = msg.uart_b.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1306,9 +873,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.tx_buffer_level + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.tx_buffer_level + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1317,9 +882,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.tx_throughput, 1.20000001043081284e-02, DELTA); value = msg.uart_ftdi.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1327,9 +890,7 @@ public void test6() throws Throwable { } value = msg.uart_ftdi.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1337,9 +898,7 @@ public void test6() throws Throwable { } value = msg.uart_ftdi.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1348,9 +907,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.uart_ftdi.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_ftdi.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; diff --git a/java/test/auto_check_sbp_piksi_MsgUartStateTest.java b/java/test/auto_check_sbp_piksi_MsgUartStateTest.java index a64feba41..b5a4375da 100644 --- a/java/test/auto_check_sbp_piksi_MsgUartStateTest.java +++ b/java/test/auto_check_sbp_piksi_MsgUartStateTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,23 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/piksi/test_MsgUartState.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/piksi/test_MsgUartState.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.piksi.MsgUartState; + import com.swiftnav.sbp.piksi.MsgUartStateDepa; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_piksi_MsgUartStateTest { @@ -28,94 +34,17 @@ public class auto_check_sbp_piksi_MsgUartStateTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateTest.test1"); - byte[] payload = - new byte[] { - (byte) 154, - (byte) 169, - (byte) 242, - (byte) 69, - (byte) 102, - (byte) 166, - (byte) 231, - (byte) 68, - (byte) 89, - (byte) 98, - (byte) 79, - (byte) 184, - (byte) 138, - (byte) 244, - (byte) 154, - (byte) 73, - (byte) 201, - (byte) 69, - (byte) 154, - (byte) 65, - (byte) 211, - (byte) 69, - (byte) 201, - (byte) 16, - (byte) 103, - (byte) 249, - (byte) 143, - (byte) 161, - (byte) 154, - (byte) 17, - (byte) 186, - (byte) 69, - (byte) 51, - (byte) 211, - (byte) 7, - (byte) 69, - (byte) 215, - (byte) 149, - (byte) 253, - (byte) 25, - (byte) 218, - (byte) 24, - (byte) 29, - (byte) 195, - (byte) 16, - (byte) 19, - (byte) 159, - (byte) 142, - (byte) 71, - (byte) 17, - (byte) 10, - (byte) 113, - (byte) 137, - (byte) 219, - (byte) 135, - (byte) 18, - (byte) 182, - (byte) 21, - (byte) 38, - (byte) 190, - (byte) 59, - (byte) 196, - (byte) 169, - (byte) 155, - (byte) 107, - (byte) 111, - (byte) 253, - (byte) 168, - (byte) 244, - (byte) 158, - (byte) 112, - (byte) 19, - (byte) 251, - (byte) 131, - }; - SBPMessage sbp = new SBPMessage(0xe0c8, 0x1d, payload); - MsgUartState msg = new MsgUartState(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateTest.test1"); + byte[] payload = new byte[] {(byte)154,(byte)169,(byte)242,(byte)69,(byte)102,(byte)166,(byte)231,(byte)68,(byte)89,(byte)98,(byte)79,(byte)184,(byte)138,(byte)244,(byte)154,(byte)73,(byte)201,(byte)69,(byte)154,(byte)65,(byte)211,(byte)69,(byte)201,(byte)16,(byte)103,(byte)249,(byte)143,(byte)161,(byte)154,(byte)17,(byte)186,(byte)69,(byte)51,(byte)211,(byte)7,(byte)69,(byte)215,(byte)149,(byte)253,(byte)25,(byte)218,(byte)24,(byte)29,(byte)195,(byte)16,(byte)19,(byte)159,(byte)142,(byte)71,(byte)17,(byte)10,(byte)113,(byte)137,(byte)219,(byte)135,(byte)18,(byte)182,(byte)21,(byte)38,(byte)190,(byte)59,(byte)196,(byte)169,(byte)155,(byte)107,(byte)111,(byte)253,(byte)168,(byte)244,(byte)158,(byte)112,(byte)19,(byte)251,(byte)131, }; + SBPMessage sbp = new SBPMessage( 0xe0c8, 0x1d, payload ); + MsgUartState msg = new MsgUartState( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.latency.avg; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.avg + "' != '" + 319865629 + "'", - value.equals(BigInteger.valueOf(319865629L))); + org.junit.Assert.assertTrue("'" + msg.latency.avg + "' != '" + 319865629 + "'", value.equals(BigInteger.valueOf( 319865629L ) ) ); } else { value = value.longValue(); expected = 319865629L; @@ -123,9 +52,7 @@ public void test1() throws Throwable { } value = msg.latency.current; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.current + "' != '" + 364253831 + "'", - value.equals(BigInteger.valueOf(364253831L))); + org.junit.Assert.assertTrue("'" + msg.latency.current + "' != '" + 364253831 + "'", value.equals(BigInteger.valueOf( 364253831L ) ) ); } else { value = value.longValue(); expected = 364253831L; @@ -133,9 +60,7 @@ public void test1() throws Throwable { } value = msg.latency.lmax; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmax + "' != '" + -611749622 + "'", - value.equals(BigInteger.valueOf(-611749622L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmax + "' != '" + -611749622 + "'", value.equals(BigInteger.valueOf( -611749622L ) ) ); } else { value = value.longValue(); expected = -611749622L; @@ -143,9 +68,7 @@ public void test1() throws Throwable { } value = msg.latency.lmin; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmin + "' != '" + 289902239 + "'", - value.equals(BigInteger.valueOf(289902239L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmin + "' != '" + 289902239 + "'", value.equals(BigInteger.valueOf( 289902239L ) ) ); } else { value = value.longValue(); expected = 289902239L; @@ -153,9 +76,7 @@ public void test1() throws Throwable { } value = msg.obs_period.avg; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.obs_period.avg + "' != '" + -1002717658 + "'", - value.equals(BigInteger.valueOf(-1002717658L))); + org.junit.Assert.assertTrue("'" + msg.obs_period.avg + "' != '" + -1002717658 + "'", value.equals(BigInteger.valueOf( -1002717658L ) ) ); } else { value = value.longValue(); expected = -1002717658L; @@ -163,9 +84,7 @@ public void test1() throws Throwable { } value = msg.obs_period.current; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.obs_period.current + "' != '" + -2080697488 + "'", - value.equals(BigInteger.valueOf(-2080697488L))); + org.junit.Assert.assertTrue("'" + msg.obs_period.current + "' != '" + -2080697488 + "'", value.equals(BigInteger.valueOf( -2080697488L ) ) ); } else { value = value.longValue(); expected = -2080697488L; @@ -173,9 +92,7 @@ public void test1() throws Throwable { } value = msg.obs_period.pmax; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.obs_period.pmax + "' != '" + -1628133123 + "'", - value.equals(BigInteger.valueOf(-1628133123L))); + org.junit.Assert.assertTrue("'" + msg.obs_period.pmax + "' != '" + -1628133123 + "'", value.equals(BigInteger.valueOf( -1628133123L ) ) ); } else { value = value.longValue(); expected = -1628133123L; @@ -183,9 +100,7 @@ public void test1() throws Throwable { } value = msg.obs_period.pmin; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.obs_period.pmin + "' != '" + 1869323177 + "'", - value.equals(BigInteger.valueOf(1869323177L))); + org.junit.Assert.assertTrue("'" + msg.obs_period.pmin + "' != '" + 1869323177 + "'", value.equals(BigInteger.valueOf( 1869323177L ) ) ); } else { value = value.longValue(); expected = 1869323177L; @@ -193,9 +108,7 @@ public void test1() throws Throwable { } value = msg.uart_a.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.crc_error_count + "' != '" + 25177 + "'", - value.equals(BigInteger.valueOf(25177L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.crc_error_count + "' != '" + 25177 + "'", value.equals(BigInteger.valueOf( 25177L ) ) ); } else { value = value.longValue(); expected = 25177L; @@ -203,9 +116,7 @@ public void test1() throws Throwable { } value = msg.uart_a.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.io_error_count + "' != '" + 47183 + "'", - value.equals(BigInteger.valueOf(47183L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.io_error_count + "' != '" + 47183 + "'", value.equals(BigInteger.valueOf( 47183L ) ) ); } else { value = value.longValue(); expected = 47183L; @@ -213,9 +124,7 @@ public void test1() throws Throwable { } value = msg.uart_a.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.rx_buffer_level + "' != '" + 244 + "'", - value.equals(BigInteger.valueOf(244L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.rx_buffer_level + "' != '" + 244 + "'", value.equals(BigInteger.valueOf( 244L ) ) ); } else { value = value.longValue(); expected = 244L; @@ -224,9 +133,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.rx_throughput, 1.85319995117187500e+03, DELTA); value = msg.uart_a.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.tx_buffer_level + "' != '" + 138 + "'", - value.equals(BigInteger.valueOf(138L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.tx_buffer_level + "' != '" + 138 + "'", value.equals(BigInteger.valueOf( 138L ) ) ); } else { value = value.longValue(); expected = 138L; @@ -235,9 +142,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.tx_throughput, 7.76520019531250000e+03, DELTA); value = msg.uart_b.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.crc_error_count + "' != '" + 4297 + "'", - value.equals(BigInteger.valueOf(4297L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.crc_error_count + "' != '" + 4297 + "'", value.equals(BigInteger.valueOf( 4297L ) ) ); } else { value = value.longValue(); expected = 4297L; @@ -245,9 +150,7 @@ public void test1() throws Throwable { } value = msg.uart_b.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.io_error_count + "' != '" + 63847 + "'", - value.equals(BigInteger.valueOf(63847L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.io_error_count + "' != '" + 63847 + "'", value.equals(BigInteger.valueOf( 63847L ) ) ); } else { value = value.longValue(); expected = 63847L; @@ -255,9 +158,7 @@ public void test1() throws Throwable { } value = msg.uart_b.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.rx_buffer_level + "' != '" + 161 + "'", - value.equals(BigInteger.valueOf(161L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.rx_buffer_level + "' != '" + 161 + "'", value.equals(BigInteger.valueOf( 161L ) ) ); } else { value = value.longValue(); expected = 161L; @@ -266,9 +167,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.rx_throughput, 6.76020019531250000e+03, DELTA); value = msg.uart_b.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.tx_buffer_level + "' != '" + 143 + "'", - value.equals(BigInteger.valueOf(143L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.tx_buffer_level + "' != '" + 143 + "'", value.equals(BigInteger.valueOf( 143L ) ) ); } else { value = value.longValue(); expected = 143L; @@ -277,9 +176,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.tx_throughput, 6.44120019531250000e+03, DELTA); value = msg.uart_ftdi.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.crc_error_count + "' != '" + 38359 + "'", - value.equals(BigInteger.valueOf(38359L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.crc_error_count + "' != '" + 38359 + "'", value.equals(BigInteger.valueOf( 38359L ) ) ); } else { value = value.longValue(); expected = 38359L; @@ -287,9 +184,7 @@ public void test1() throws Throwable { } value = msg.uart_ftdi.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.io_error_count + "' != '" + 6653 + "'", - value.equals(BigInteger.valueOf(6653L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.io_error_count + "' != '" + 6653 + "'", value.equals(BigInteger.valueOf( 6653L ) ) ); } else { value = value.longValue(); expected = 6653L; @@ -297,9 +192,7 @@ public void test1() throws Throwable { } value = msg.uart_ftdi.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -308,9 +201,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.uart_ftdi.rx_throughput, 2.17319995117187500e+03, DELTA); value = msg.uart_ftdi.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -323,29 +214,17 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateTest.test2"); - byte[] payload = - new byte[] { - (byte) 26, (byte) 191, (byte) 93, (byte) 63, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 24, (byte) 0, - (byte) 123, (byte) 50, (byte) 62, (byte) 64, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 40, (byte) 0, - (byte) 54, (byte) 7, (byte) 162, (byte) 64, (byte) 177, (byte) 57, (byte) 16, - (byte) 61, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 81, (byte) 1, - (byte) 255, (byte) 255, (byte) 255, (byte) 255, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 255, (byte) 255, - (byte) 255, (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x18, payload); - MsgUartStateDepa msg = new MsgUartStateDepa(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateTest.test2"); + byte[] payload = new byte[] {(byte)26,(byte)191,(byte)93,(byte)63,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)24,(byte)0,(byte)123,(byte)50,(byte)62,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)40,(byte)0,(byte)54,(byte)7,(byte)162,(byte)64,(byte)177,(byte)57,(byte)16,(byte)61,(byte)0,(byte)0,(byte)0,(byte)0,(byte)81,(byte)1,(byte)255,(byte)255,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x18, payload ); + MsgUartStateDepa msg = new MsgUartStateDepa( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.latency.avg; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.avg + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.avg + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -353,9 +232,7 @@ public void test2() throws Throwable { } value = msg.latency.current; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.current + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.current + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -363,9 +240,7 @@ public void test2() throws Throwable { } value = msg.latency.lmax; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmax + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmax + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -373,9 +248,7 @@ public void test2() throws Throwable { } value = msg.latency.lmin; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmin + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmin + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -383,9 +256,7 @@ public void test2() throws Throwable { } value = msg.uart_a.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -393,9 +264,7 @@ public void test2() throws Throwable { } value = msg.uart_a.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -403,9 +272,7 @@ public void test2() throws Throwable { } value = msg.uart_a.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -414,9 +281,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_a.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.tx_buffer_level + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.tx_buffer_level + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -425,9 +290,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.tx_throughput, 8.66197228431701660e-01, DELTA); value = msg.uart_b.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -435,9 +298,7 @@ public void test2() throws Throwable { } value = msg.uart_b.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -445,9 +306,7 @@ public void test2() throws Throwable { } value = msg.uart_b.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -456,9 +315,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.tx_buffer_level + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.tx_buffer_level + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -467,9 +324,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.tx_throughput, 2.97183108329772949e+00, DELTA); value = msg.uart_ftdi.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -477,9 +332,7 @@ public void test2() throws Throwable { } value = msg.uart_ftdi.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -487,9 +340,7 @@ public void test2() throws Throwable { } value = msg.uart_ftdi.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -498,9 +349,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.uart_ftdi.rx_throughput, 3.52112688124179840e-02, DELTA); value = msg.uart_ftdi.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -513,29 +362,17 @@ public void test2() throws Throwable { @Test public void test3() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateTest.test3"); - byte[] payload = - new byte[] { - (byte) 237, (byte) 232, (byte) 95, (byte) 63, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 24, (byte) 0, - (byte) 198, (byte) 186, (byte) 63, (byte) 64, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 40, (byte) 0, - (byte) 214, (byte) 72, (byte) 217, (byte) 64, (byte) 29, (byte) 72, (byte) 180, - (byte) 62, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 85, (byte) 1, - (byte) 255, (byte) 255, (byte) 255, (byte) 255, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 255, (byte) 255, - (byte) 255, (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x18, payload); - MsgUartStateDepa msg = new MsgUartStateDepa(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_piksi_MsgUartStateTest.test3"); + byte[] payload = new byte[] {(byte)237,(byte)232,(byte)95,(byte)63,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)24,(byte)0,(byte)198,(byte)186,(byte)63,(byte)64,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)40,(byte)0,(byte)214,(byte)72,(byte)217,(byte)64,(byte)29,(byte)72,(byte)180,(byte)62,(byte)0,(byte)0,(byte)0,(byte)0,(byte)85,(byte)1,(byte)255,(byte)255,(byte)255,(byte)255,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)255,(byte)255,(byte)255,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x18, payload ); + MsgUartStateDepa msg = new MsgUartStateDepa( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.latency.avg; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.avg + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.avg + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -543,9 +380,7 @@ public void test3() throws Throwable { } value = msg.latency.current; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.current + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.latency.current + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -553,9 +388,7 @@ public void test3() throws Throwable { } value = msg.latency.lmax; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmax + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmax + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -563,9 +396,7 @@ public void test3() throws Throwable { } value = msg.latency.lmin; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency.lmin + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.latency.lmin + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -573,9 +404,7 @@ public void test3() throws Throwable { } value = msg.uart_a.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -583,9 +412,7 @@ public void test3() throws Throwable { } value = msg.uart_a.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -593,9 +420,7 @@ public void test3() throws Throwable { } value = msg.uart_a.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -604,9 +429,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_a.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_a.tx_buffer_level + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.uart_a.tx_buffer_level + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -615,9 +438,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.uart_a.tx_throughput, 8.74647915363311768e-01, DELTA); value = msg.uart_b.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -625,9 +446,7 @@ public void test3() throws Throwable { } value = msg.uart_b.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -635,9 +454,7 @@ public void test3() throws Throwable { } value = msg.uart_b.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.rx_buffer_level + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -646,9 +463,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.rx_throughput, 0.00000000000000000e+00, DELTA); value = msg.uart_b.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_b.tx_buffer_level + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.uart_b.tx_buffer_level + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -657,9 +472,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.uart_b.tx_throughput, 2.99577474594116211e+00, DELTA); value = msg.uart_ftdi.crc_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.crc_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -667,9 +480,7 @@ public void test3() throws Throwable { } value = msg.uart_ftdi.io_error_count; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.io_error_count + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -677,9 +488,7 @@ public void test3() throws Throwable { } value = msg.uart_ftdi.rx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.rx_buffer_level + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -688,9 +497,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.uart_ftdi.rx_throughput, 3.52112680673599243e-01, DELTA); value = msg.uart_ftdi.tx_buffer_level; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 85 + "'", - value.equals(BigInteger.valueOf(85L))); + org.junit.Assert.assertTrue("'" + msg.uart_ftdi.tx_buffer_level + "' != '" + 85 + "'", value.equals(BigInteger.valueOf( 85L ) ) ); } else { value = value.longValue(); expected = 85L; diff --git a/java/test/auto_check_sbp_piksi_piksi_structsTest.java b/java/test/auto_check_sbp_piksi_piksi_structsTest.java index b98da2645..0aabd50f3 100644 --- a/java/test/auto_check_sbp_piksi_piksi_structsTest.java +++ b/java/test/auto_check_sbp_piksi_piksi_structsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,10 +9,19 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/piksi/test_piksi_structs.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/piksi/test_piksi_structs.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; + +import org.json.JSONObject; + +import com.swiftnav.sbp.SBPMessage; + public class auto_check_sbp_piksi_piksi_structsTest { diff --git a/java/test/auto_check_sbp_profiling_MsgMeasurementPointTest.java b/java/test/auto_check_sbp_profiling_MsgMeasurementPointTest.java index a7338fcec5c7a15edf10dfd93b031a96f2b6a64e..5c67de2bbf03318ade2a1f0f5c6ec093fb115b16 100644 GIT binary patch delta 842 zcmZqDnykj6uf?S>kx_!taHG@_#>saXT_>wD#Rw|o=BH$)RVpM^Dr6+)r6_Vu{>UUJ z!Iha?kY7}ykYALpmsOgVS)vz`T3lkyHJOiDcJeeP)ycb#xgQ6gqmh(VgYBt z#4KTsvM|MAry*PuUL(QQ)dT$tvlpE+1T$ZC70(T5d!q5PHqqip1hND|KwgSH%ADwr5RL^nI|a57Gg<8|Rs zFoLQB>Hf)kVDdRWgUOq?6uE#VKow608PUyuU~+EBaqnw3PxszmS)BlCQ!>aHwcL{PF^Fd3zFqlFaqjCa#e=NECBbE^tk{4 literal 5378 zcmc&&@o(BV6uzJNE8dW%!mSG=g_iC#=_sVP+(AGkj-*bRC z>}b_#N0(n>?DxL+`Fr-WL*-{^iRC(G^M!&^s|-%nuD^DwjswG6HdEk}6`K>q1P6}? zRspmFS0qqxV4>7fzNu7XvRsN-SyFp&va$jZp`o@NEtmu;k~pBCTgl`T4HPH=YC$1n z0p*gyOeA~?jHjJ57E(CrcrDi-x+ieEV8H^SL@JFpp)h4q#cYx&Iz^m0MW7gNnOdNC z7R-WX7=lR0(#c7Psig6WPW2p8YVW)uw0dn9ntmHR|GGEmHb-912kh?;dhflq+lFFu zh`)>Q!5h8n-HhNvb1-Q7qmR(LM!%2nhv&CXHJpnE?f~3B`vZ44M9Ek&jJrBJ9;HVH~4za%9=!BWtZp*VpW#0K!3*Psl~V}=Uqx<64Qus)fbE_ zOFO}24Lf9OxwfD!fD5JJBQa&OwKiA~K7COr6j-De)PH#oulijoCC=%W2W>Jw)&VM+ z+b6OjRz%dox?*#WD>|ofHYnn`^+^hD{XXpZy>!X$k0qQbYqSw@nM`mULl6?V5pWzV zXz+QA+Ke+Uhh)+I@TE`ye6}D`;Z_S^B1A|Dhbf&Tb9f6g5=xwLY8bN><_5NwGsZ~> zQ-K^PwB63AiRLzaZPziq+WuD^B_CoX815VFv`b~&F|oLnxCrn?G{l$GR6DX6l+yU+ ztV?$f*HY2Q5{a^AB1QpA#h3i0e94QaP}IxkTV|iGL%UesOija2){6f1H!R6I6l4l- z_hM@UPH%TchN~XfJtYl+b*x@Jg>CyHYneXNvKyvtS`KdN1J4%G*d1!s4t3`H9)q^e zj3pN1jJjQGq;KaypAgtkdujmVaekh$JFjI;yKeZ~-_GB_n^ta4 zxlTJ5)3zU#$F_5vY(v}5r6ZT)nn}h1RqoB=Hq{HTIN(Ori`jIRs&{s^ij=E&t!w?> z?tapD0TzfD>jo{Af68z9G{}|-%Yo_wv>9U@ zs~r!hn1LzQXn8F_n(U zoq>Nop)u^f&b8`Ob*@#9qBFu8A^!gr9Wid;pHXN0xY@5UPnFp@iptJWMdnE~rgt<* z^mn8D5qj@4*q0tJd|UCeny1&is2-DIC{2js%< zr{nUhadA<*sMno~YVA8t+p&i8Df z4CFYKZAbB_=}|(F@Q0=xZ$gNq8MI%BSJlClTJOw-?|0!hPXi1B}b< diff --git a/java/test/auto_check_sbp_profiling_MsgProfilingResourceCounterTest.java b/java/test/auto_check_sbp_profiling_MsgProfilingResourceCounterTest.java index 6bed77887e930bf300c150b6a254662e1008ea4f..c4b50c35e1c7447fa818588f6352e25434001ff5 100644 GIT binary patch literal 22802 zcmeHP|8Lqz7T=%wE8ZeiC3~r13ohYI`v=kD&ovsdc?YUd}QH(2|X-q0CL@9kv( zL-WpFnSt#(U^tc*DmZ~@1wX<%2zLID^}4^`?OZR=e4*i(cbesHQBcUv*0vA6yZ0;( z;%GmA%dG$c7lJj1jcswq=dg75&H`*lb}sD=hnH8z`CvF5yoCF;ZLMLu_XA;X&S7Eu zfoIS60bih<6-PrJ+}pt#wPR-*^fw!D>p1?zZe&T3#j&|_`3?f8nZW}n;HDtpG^A0*>5nqM7`hOKgRIlRG1r} zz+eJ{|Bfev=@d0b6ELpFSH|Gt6s@0M-CP*MpW!vy7>;IeWn3FGl$wnI^+-|}iaZ#D zsqk?)Vceh0jPskT{shK1lksRe5QD5&Dm&A9 zXRbJ4LXzzG^PLuOKlo>*Qm=;@l9=C{KA8K!eYN5a_e_EB(sQ@q@3>VL3V!{;+-~ZW z<~kax?>rZkZD%DVZm<2-n0h8WO#C@!H{hNolwtk=WM11nXmH_z;|8#G7xwZ&oL!sF z;`>U)-ij#&Z_PVX+nT{zdu^`_G_&F!#vPq?y_NQM@7RGh3&(TV@4Jrn@9Ahbl2a~G zdW6OF_4u0mKH~I@P&`iUnIWQnWw)Q>v<7Qq`XQXR)|y-IZV{~8*vNA@iJ`!UN(Jy= zWXuon3bbJEx*Kjfu;BCk3Vwp6x$!Y(Dd^dEm@$YXm$qYWVBumc94-b|vp$M5{))9R zL?Qn#;pNc9oonOegq^H*f)|qK-upN;urY;+4^mVp+DoWO|0i*m=$=0K0pDuwKG2q~ zhY71yUpO!P7f$sQs$x=o2?}zSvg%1VMB!%s5b)psfSviUam@ve$>I0Z`JpDxp0Lxf zZANXU5gjnriI3WJ)QFE5DKbVHO+6NSe3CWD13NH6s;og8)bph+*`ZjdC3||S8%5cq z1J;UqNT%qvL!P_jxl3Vo2&FCs5u@7c#qg5;0hBR-Nj?}m`^p0&aGz@RCPf{OgGA}X zr&<eF>MA?@7cPMy9<2rk4M)u?Dq(c#OX^AC~|Cg4~ ze6rQ)lIoDi*ABf$*suoWH0y#flIg{(BzsCYtE~Drg-Y=~YFjiP*%^WRxiPXX%`DcY zypUD0rMJj4Nzj?bDSS-$L_+-l`B}s#lFk}5-s6RjI*s?%5;y#qc^q((XZRp&eZkWN zNqI)9CVd}ROjs+tMHY(|(2f?kqQ7<^H{5UMSo_?Wn|(wB1xJc{`Fo`8$l;U0O1a3` zd~dzuf&Y8s56!wuLjfJ{DJjhMX6hnYZV)>dPwp zLk6Dmg?-hR@cmC9PwVn0azyD=1C+5QxgGk!J*w@_L-3p58-}X96A_9Rm5s=Hf{m(_EIod34JpisaGXv^{#-PQN<%}{MPa*1s*48Q zcFT7ibV!p+j!td2BDAHXT?QfFMJVEm!N|d2F zj=AM{&+l^Yi)RMhS=kQ%F8WtJibfF6UrL)N7&pfo06}1C1B|9)vNdKj; z^5UE&;fj_iL_O;{or7+x)o$gU?^3#`IUgENfGLjqr%_SJ{U19{XQMRSAAwND{iUxo z&ShHRkryi5QYF|&xIgQ)_58D2N*A@xgvJ%EGsMahcZHT-A^b<`fNrOkf0gg_iozbl zP{nLiRs#t8k!s+ZTxIfC0|-h~4Gd=!V~p=a*xU)I82Ij!)d1=%tp;L$CEY7@h1G!c zRbHI4oLtfFfT(9Zr*qJ1>fKJ~EcZ?k$rrU-kog3j;%b64HVSKk$BxrE$a^i^h@Rn`O&>?1Wnxn_2FcRpFl3atY|$dA+kWx`x#1%QD6T>*%{2)^W$4zcdwA0Mb`^anAB^Mf(Dxp7os0f!^vc z_8E^crFc>NKMY364Wl$L3hDo2$LWNWX2V7xl+l0btIRm7r2i7^GSmMM0F|!;9e6D7 zELTbY5%44Q|10Dz!G^nc7f8~?=9O7Z_s(tp%fO8;Yj>1(Dm^uMK$ z{!3rw#W_pD714i0J?lA>gKo3YmR-4Ce-qM0tz1kRPk<@z)_)omh1~zK<8(Gk!~GEm zW!zu-O5}GV$LVa8rVcuCC2Lsvn zf)JFbAi&S=d_h5g`brCe*k5|P$bX}>u$!dqLYFO{|9QLNPI6fmLP{eqX>6Ohw}oa= zi&C?2Y@MP%e>e3T;BZh7eeW##`6hpk5h+ho8^zaXn7Mq75 QeygB%5`Dz!W94JzfBDg=EdT%j literal 30109 zcmeHQVRPEJ7TwSM3N168l6|Q`1_JC(XC6(+*6$_20NH&zJ3AR;1h@s8wN28@PXGH} z$u`Cbxz4L=#1`jE8%w%6x<|Uw@m1aO59HilJvioU?vc{@2~jJw{zk2+DjD9JQ;&4@ zJ9DOcrfm_;GL!=04J=PLydTNj^H%PU<+8h8t!&3rT;9Uc?-avcLPcJ8G&f!1+H1#P zg#T?l{=f{6csB9oj4VupSuP_}du>gKX^DqZbHT{#EA70~9d=%m`?+b%$#U&_+}@ax ziRpTdIbM5g0(NE$3_0Z9^ybid)0slriv_VonHZc)9Og3Tj!pO&1hn_skev4}I;7pb zAX@jbH@I$(v|g9M^Zuasi+0huAjS3&elL<=wbA?D&4~Qk9t_&u(Ql-83GIF(|JAw| zr`%izDs%><^S}O}GaN$8-hgP={VT0=aSGPYuWl~1?$6{M*y#2~gF-HB-i2j* zWNA;#=>xAY*R9F-g+jqx@`?2n|L|S^nz=5F?Wbq!Y;Y+Eq)qb=`kk&Ub#Jb`GiMs0 zoiS%qXgf3IgKJyLe}=toPfX!>+1fHaW#l_`wI0K~CdNW{eTUu}b7p+J1z+86Fkx=u zcF13a0)d~vnCrn3G|1St7fiRvgpJoT@|H~Xg$o`K6&>>qI3q#LscGp8GO+;*BNv^k zQ5&jL_J-Dhc3%JAyqE1R?ram*6Fj7)6Ie-(eec5LfIoC@;xAE^H#DcDB>F$uJmQas z53a|SioN!fsqKIxOR-{Jh5r;^S+CqzR`HY+`CR)F*NDkWizoiLxzX{1$A15Vtn`P4 ztxw3?Cp}y2KCBcCgtrWTO5DT=p|Fy7`~;;{w6sw{iz#g+l-Kd{N5Y} zP>LgRQh00O?`ZJom&PG^+pjh85>DR@oZ%+^k}ap{Yti)Wc@mFl8J4QJSZLr~e|tn^ zH=-6E9cTsLxzYfm6z{v0@aBqU2QAI8^0tQ`Q1OX}&#P3WHT=9q&+x$aPn=t{iJwns z9gpU?$8e9RHJmNHXWaIV($7);Hp=D`NRmUMn&)eyho#CVP=%FKQu$;|A&(d)dbcvb zNQR#*U7jlECXret=y=Osl;PT#;(2dc zQm;-o9$5gObFEK#|k3Ma#Woda`2}%nkt~ zCnh9j373vPNseCvL!6SMIIcZ&(hUxLj}CE`zGQI4^m6U;i|fpqnHKvl_}RWW`pg*+ zuD{9;i#~`r(^UNWg$Hw*$;pB4<>WwRt0Vy+CqqO+@Wo?UA~PuNfD0ODjE^R9CM5=k(!Ln6^uT}`!4gn>-L zns0eeVJ*}tQFr^7u|7vTsZ0YnAO`Nz?N5X${b_pCKS2_s*IT>NNI{@h<7}+76j(d&x zX`Lu??q4qXyzG!m$4rcLp#-etLMe8SYDabnoD>M9;c%e#hJ%ep5`Re&O3+-sP}+cq zZ&pVkiFc*^s7?R(7bQbO(TJ z_WrNF?Y}&o1WpQ6QlB{{eAm;6$)qHe1kL5Eqz#Dp;yYTERFkce1c00j5edN;hoq8r zzt0iBop85(yk5S0V`jaWam1*Es-* zBpBHtk<>G_(nu55gn>-Lns0eeVeJs^;Q1WoNu@}~f=8swr4YjrhO?K;C2&$8m$d7f zm{NLCQVE*NmrENEN67T9q*7hBToM4{WE{m?if70;B)J6CJcbh|s#dM1J68w;nVc(p z%lkN2#Jwb2E*P7}+70YOSW==?mWhLGx@v8ra=a zKsyAXFwD5=$Yt)A*lgKr@dk^<9v;z_!00+RAHQ_^KTa8jU~;QMX=zixu&@^#Y& zM0^KJ^|Cyh7v=R#gQUy;yj?IWTHpJ-mK<~)C!iYaRQ}ifkPqHfGYNOq%$;pX`4kuT zwe{#5T;Z0J=;}lNgvsXPg3rAA>Dpd!rML+H1tR}w4gCM5mk#_>%gN%Q3m>g1g`ZCR IT=-o08~GI-RsaA1 diff --git a/java/test/auto_check_sbp_profiling_MsgProfilingSystemInfoTest.java b/java/test/auto_check_sbp_profiling_MsgProfilingSystemInfoTest.java index bff1222df..3ad033db9 100644 --- a/java/test/auto_check_sbp_profiling_MsgProfilingSystemInfoTest.java +++ b/java/test/auto_check_sbp_profiling_MsgProfilingSystemInfoTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/profiling/test_MsgProfilingSystemInfo.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/profiling/test_MsgProfilingSystemInfo.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.profiling.MsgProfilingSystemInfo; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_profiling_MsgProfilingSystemInfoTest { @@ -29,24 +33,16 @@ public class auto_check_sbp_profiling_MsgProfilingSystemInfoTest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_profiling_MsgProfilingSystemInfoTest.test1"); - byte[] payload = - new byte[] { - (byte) 98, (byte) 40, (byte) 52, (byte) 0, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 114, (byte) 12, (byte) 157, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 27, (byte) 72, (byte) 195, (byte) 226, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x1000, 0xcf01, payload); - MsgProfilingSystemInfo msg = new MsgProfilingSystemInfo(sbp); + System.out.format("%n%s%n", "auto_check_sbp_profiling_MsgProfilingSystemInfoTest.test1"); + byte[] payload = new byte[] {(byte)98,(byte)40,(byte)52,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)114,(byte)12,(byte)157,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)27,(byte)72,(byte)195,(byte)226,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x1000, 0xcf01, payload ); + MsgProfilingSystemInfo msg = new MsgProfilingSystemInfo( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.age; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.age + "' != '" + 10292338 + "'", - value.equals(BigInteger.valueOf(10292338L))); + org.junit.Assert.assertTrue("'" + msg.age + "' != '" + 10292338 + "'", value.equals(BigInteger.valueOf( 10292338L ) ) ); } else { value = value.longValue(); expected = 10292338L; @@ -54,9 +50,7 @@ public void test1() throws Throwable { } value = msg.heap_usage; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.heap_usage + "' != '" + 14861128 + "'", - value.equals(BigInteger.valueOf(14861128L))); + org.junit.Assert.assertTrue("'" + msg.heap_usage + "' != '" + 14861128 + "'", value.equals(BigInteger.valueOf( 14861128L ) ) ); } else { value = value.longValue(); expected = 14861128L; @@ -64,9 +58,7 @@ public void test1() throws Throwable { } value = msg.n_threads; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_threads + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.n_threads + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -74,9 +66,7 @@ public void test1() throws Throwable { } value = msg.total_cpu_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.total_cpu_time + "' != '" + 3418210 + "'", - value.equals(BigInteger.valueOf(3418210L))); + org.junit.Assert.assertTrue("'" + msg.total_cpu_time + "' != '" + 3418210 + "'", value.equals(BigInteger.valueOf( 3418210L ) ) ); } else { value = value.longValue(); expected = 3418210L; diff --git a/java/test/auto_check_sbp_profiling_MsgProfilingThreadInfoTest.java b/java/test/auto_check_sbp_profiling_MsgProfilingThreadInfoTest.java index bad590435984c587f5f64cb95fd9542ce9546609..64204385133e94928e39f1af594a6f6cd95f8a19 100644 GIT binary patch delta 670 zcmcbwx=EHrUyDm&BBKPO;YO(=jFay&x=vPQiWgMK%}>cpt5is;RLDroOHt&S{GCZ| zvH`QCOlEFDeo=`+eo?w!R&jowo>#EHpMO$TYI2D+*W|rSl03mq0lull#fj;uU;*pR z?#!%=lM`7I>J{=*%Yi1Aq(;XoRBM13nudm!IuMqnA(UZg0A&zM8^U#%!i+G5v5?KE z2U& zo6O0rHQ7i&kzc{kz|hpv#N5C~K@$ik2k-_>KFU3jSwYi!@<(3j$;CX8lOOUJfYkCS zSQuMam>F0=lx_~-6=R%S%?Fm_RWLF)wKPID#hQQbWL^O`4h2IbqgM(XoLnzx3^I;a Q!OYyk+}so@`$6zM0BPmG0{{R3 literal 4831 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 diff --git a/java/test/auto_check_sbp_settings_MsgSettingsReadReqTest.java b/java/test/auto_check_sbp_settings_MsgSettingsReadReqTest.java index 50c4c56005cb1185209312ed15e0cabe00bf6c55..e072f8743fe78a0d689af67873e7a61fb0b7bcbf 100644 GIT binary patch delta 423 zcmca1w1AIAUyDm&BBKPO;YO(=jFay&x=vPQN_0?2s#M5G%u7+^;>ye|$S*2U$Vx0r z)XPmQ$`6r g5-W4^6H^o>D{xq|DikLbC`^vySjng`nVmBb0L)l?^8f$< literal 2392 zcmdT`QE%He5Z<$X#nnJid2l2vYr3UHfho4qXtgCnQq~p25Kt0rvz16yr0f_){`-!y z6{kpR59rhMV(a+bcXvGAN7+BaNK~7eEtU$*Q6J8R&iU!t@azoYHJd94$cin9VuFLu zGs^(&z!k~VD_AO3$yc^5o2nAEvZVIlWMyTdM4-kdOC~{zrp_qne@*(4W(t%5wWLt6 zjB-g~E*hQ#Ter?>VfOEL%d^NTvBw3OSRiW@)2njywyBL^Z6LTB7$u zFbmwG0MV|s#Yw2Cr1gsCx`sBjYd?ljIQGB|#^486VKj9UKMVlvvnc%2AA4iyxiP-? z;Ju$*hc^klccaJ+k`EAGq2C91=Lh3~rt=WsMd1B4i@Z2S&oBaiI-B_3c!2Dq$<5dg z-ohnv1YrUbf9fZQN^Oc_j7zQwDaAD>~ zi9foTxDm{5qFESwx=7ooNcM>=C}2PK&5>zkDJs=#!?5jbgW4@$6A7eI;&eedt%=^= zd5w)kkgRBCYaeNENLkojqiy7}B~^;?g=_)0Q@MzDhKQ0pqMt480_g@iUaQ(zFc!dt zf>PvczR@udup~TxW*7!5^>KQdb$mISQYo>b*Wbl-*;r2#d2kZ-!ulu$xBiI3AZ$v%QoD>oZYJoLd;l{%bIcJ;{kPFO!!q}T6F2Wsp>YQWmH2!xT<#C9WU^oQ+#Qm+L6t{Y~%MIOxhf8q@txI8fDEzT@q#XPWXvD;k^O$^x63DwYNvi z>GijTY4UWV=->Z9MK*;XIlTEQvIcOv?m+uY^+NZUnxYSmbB+`Dji*~5ItSM;E)Fg` z&dbB=!z1CH!{Hrgc#!|aG5W*q7r!24cZNr*KeBm;ga2r2j_&;r_vT3c!(R^W-v6#Q z_xt(Vt0$m#p_1r%+Z)Z{UHAdE~v9TF}yq zZs=?&q3z})T+oy$-sdY)G&@n$gTAxUJG_YSV%itgN_i{SuEgtIS*X(Z<9%*WRZSgY zr_m^25`FPI=9H6?{Juk?juf?S>kx_!taHG@_#>saXT_>wDC21%mRVrj8=A|fdab@Nfg6VuWav3%rhDd271)+^+tmIF;FNsW$G zsMY{6Gz|?+b)YN*LnzDA5+-D524fk(l^Md685$ZuWla#0Fd<8GxK6lf^>7kaB*E{7X|#q$(dZvk}?lJ8+chKA<#@F2l(2s~sEfeO?BR}Tw9 zQy9b05N0lRtKd3eHkkl*)`Mf*!~`Zusu`xRa3j+QK45w?g*nJTXYv&u9Y%#oyrMh` sn$}zjP%t@=NqDj`uRNeJzxNKd z<3#HPRr}DbR9=8P_nvb*M6l}4S&>nW6-!lhi{a(Kh!J5q_xMal^L^7U% zlSR4)Dj<_2l5b!sWiH+rhA8u#7g850A|oq3;wd^R-*CwU2woNu1@%Mb_4qrtd}fWLRt!`@MaWZCS<{8rKB<9EGPmMux4_J z(NAPLSV;oBTC0i^P*6dO6^&I5Rcg0R07GwNgXNCEac?|-Vug<90@|m(_nR}aN6@kY zd~d-!C%pCULU?ESzU7AR!Mnk@_wcLZj=BoYMhDvm`}e7D2LVQUJ~)%<*s(`lL?4dt zMvnV4TqB0-g)nv|PKaKi2N<{aR6sih#|{+7#P)}`NN8OH1r;(vzgs~xMV(bTPAeJGhlq_3_%He(@7QxQoQxf}B5v^+lh3I{J}Jo}zfM&_4*C>AwV? z>s5R5d@FDntnp+Ya4FOB#K=$KvnzY{%+W;qXb*0IwZ}ka(0Lm~oy^ zl0i&oH+v1$H#D!F{A)+k*!!=ZO+)^@*R|dI ze>OG8?pvSDMeS%C&rN-}X*Qj^`maLMzO0XK`ld8zSN~NQ)GwQ6eRKZh-k#TIe|}!O zF~0HQ2K77VKVDq@wm(w(<3Vs76eFNqL+zvl#=+R`J6k}G@rnV(yxGyIKNk)+%SLG_W{S?L4nZ`9+5vMT*r zX;e$#UyamJn&Qp=t3)N){!ADt&Ye<46(VMQ8wZ8#EhGk*^ diff --git a/java/test/auto_check_sbp_settings_MsgSettingsRegisterRespTest.java b/java/test/auto_check_sbp_settings_MsgSettingsRegisterRespTest.java index dbb3093c335480795823d419483f8dc63efe0151..eedfdb5f739300d8bde5159da9a059624ebce7e5 100644 GIT binary patch delta 829 zcmaE$a886pUyDm&BBKPO;YO(=jFay&x=vPQiWgMK%}>cpt5is;RLDroOHt&S{GCZ| zvH`QCOlEFDeo=`+eo?w!R&jowo>#EHpMO$TYI2D+*W|rSl03mq0lull#fj;uU;*pR z?#!%=lM`7I>J{=*%Yi1Aq(;XoRBM13nuZoSP==u?jAdX5Wm#IngbdAKECaYQLzpr{ zLj$O+2|^MkWN8l9Sr0c3ZUan}Ar{*W5tbrYNY=yk8W>7J{ZQh9NuxQLMshQ$0AwO<-D0Okm+bf*D{VOkv?h zni1l_u{c6;0OQ_uy18 OwD3{T1j5Os{I3CvFYe9& literal 4192 zcmeHK?QY^m6wPm*;x1AYXo?_eh7LcD9YMYdS*RBA$bFtXGFK1V}k>(62Vf@f(!L49SDdm2cP9OR5b z5(ktC3L($f6k?VO!#JUEGPL@p?U^UAn#I8k=9!QRZ$e=j3z^1~OwuXhL==HiSjBRN z-cP|aFp>m#uFH!PkWxX@C7r4o^3-lD5Bko)1j8PHWnVk)$nY)429%Fo=Yusc2T(UW z{IA1D%fE4MefVg&u3`J1z_~`hPw=y44_XS&L<7?W^Ovz}dLDW@E?A@S&@u-tMDGu8 z2bTRKTp@<-_%O6amXB7x1L#*+Dxhry%k)%?k?HntFraZ|4J{0dxwaAc+VX7-1DG@z zFg9G@>fa6x7sj{l*zrtNWV^N?!DkXtzfY6OM1{bzE)UuiDQO3?dGfp`OQOw* zoM~5aWHCu2nm#Fc8fo`}GwmnOv7LP3KG$U|mYTn5&^|+c!@)Ttz{T9lE9Q>8WaZR z&^ORrr>A-k=dA31P*L_nEP0F@2!(p1iCZV-D}k#4UqnHC$xW4G96}?H-+U4&vA4$A z&NZG%E#xWou<=Z-Ow?09X2;@~)muC?%mxtH&PAUFb6@0n- z#rLJ?dZ(iLisqFE*IzlB%HF?vHWm4I-j;Un|Jjsn%h&Fkzj-$0r%L6%DRWHmBRe_@ zNcE6&DgLn&HaZW}UiYE}od=zSt%A4g5t;)O73M+_K81F`qJi=DaCRgW6lq0YM9?Hx z^2VN>oy{kBVOo+T+cHUY+HR%v0hvBB|6P4K3C@YGA@KerHRQMWGJnsIioT?LD(05% zBI6SXhBwDkM&|TrD}Mfyr*TACHowe2^;Z7sZeDMX_Nia4+1904ZzgtWDw4X<#|(8W zpge>fr*H1@Syk?Vs{AygFKbc`^^-b$n|E{*8Gq_0@a8?_a{WC2N0OW8pwUftcJZ}b z?t~5feAsO6P2&+LGWtJdR}{JdOE`-@sA=s_QRP$&3tNJ)yIv^WfdaQ<%Yj=@0Q>oD jE(;|PHZO)>$9mPg@d|#O#*|HywT**r6!ksU9&3L9utMg3 diff --git a/java/test/auto_check_sbp_settings_MsgSettingsRegisterTest.java b/java/test/auto_check_sbp_settings_MsgSettingsRegisterTest.java index bd543cf61284bf331d849f134ebfb67e7ef17fe2..35590481c22aceb00c7f209c1ad7aa87c7586e7c 100644 GIT binary patch delta 800 zcmeB>Juk?juf?S>kx_!taHG@_#>saXT_>wDC21%mRVrj8=A|fdab@Nfg6VuWav3%rhDd271)+^+tmIF;FNsW$G zsMY{6Gz|?+b)YN*LnzDA5+-D524fk(l^Md685$ZuWla#0Fd<8GxK6lf^>7kaB*E{7X|#q$(dZvk}?lJ8+chKA<#@F2l(2s~sEfeO?BR}Tw9 zQy9b05N0lRtKd3eHkkl*)`Mf*!~`Zusu`xRa3j+QK45w?g*nJTXYv&u9Y%#oyrMh` sn$}zjP%t@=NqDj`uRN3(+Q>OYq4$T@aaa z1|CaH15^N$B$01mDdkGMu`E%pR=kj=P!Wu*&4lOZsC?sPDnRhENGPbMa{7TL5+nz? zq>!ZvWrD(-muv0y`ejV zh7;j?1KxS@b#N2IJ0}bsKYkCv6~?`X-#mZVR&XvlxFNWIOhPw`Ffs_i8&5`_J8UER zV01I|{9oV_G5jEgkvH~Y^oj$(xV@(W+A(-;q&UWIIJiba=h7Q_NQ=2zhxE+f{v@?Wsfuo{@sbXNdg*~vj z+L|!rz_^5*&(ir;k)Xqpu-Oa4Fw$J@r!UivE+=Cu1eSF1RiAx2=8;Suqj<3}KM2mu zU!%Yesy+F9tz@Y*zc<^Qu{c}lV7 zDV_^7+RYZ8h=Okf4jFGmL42xQRbV=YX2sunG%0hm#gXMEFQqx>MNVY1amr4`DQmQ$ zp|;0AD8AZecBA!BnL?j#CH?a+SdneU$qe2;qgD=#ZuU-xRMo=%YAT2p*mfUJ-H~g* z-m$go=jYmG+kUNI@6^!SdV1ULXz_b>@cQucAGPRqr>6Rv=IP15bu_iT|K{1$h(Hy()eKtR7M_YSt^x?K$ckc9Gg}QyIkFNWs)MuyvD)jZswykf@zueoNKKouz zyD`4=;`;iX^B*rxzwM8det!@g2gL{|*HAktfpIW4J9nMe{azb7cZ9b0y5xyqIU*t< z7fQ1!pd+hIq#YpZNJ@KE>adHOb1I5L6%8ot569{zg51D67)1 zl}2?0{?$kmr77Orze`k-%`b$J;@l}!RB-~q@PF=%k({3F%+Ft{G)^ch^NZ@yZdbSN q!|m0Hl5~$GU&+Pi`*a#89aRSSt9DhSl+CiOkJQc9uKs)D-uMjq^JaAb diff --git a/java/test/auto_check_sbp_settings_MsgSettingsSaveTest.java b/java/test/auto_check_sbp_settings_MsgSettingsSaveTest.java index 7d62ec331..1773abb4d 100644 --- a/java/test/auto_check_sbp_settings_MsgSettingsSaveTest.java +++ b/java/test/auto_check_sbp_settings_MsgSettingsSaveTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,16 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/settings/test_MsgSettingsSave.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/settings/test_MsgSettingsSave.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; +import org.junit.Test; + +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.settings.MsgSettingsSave; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_settings_MsgSettingsSaveTest { @@ -26,10 +32,11 @@ public class auto_check_sbp_settings_MsgSettingsSaveTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_settings_MsgSettingsSaveTest.test1"); - byte[] payload = new byte[] {}; - SBPMessage sbp = new SBPMessage(0xe0a2, 0xa1, payload); - MsgSettingsSave msg = new MsgSettingsSave(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_settings_MsgSettingsSaveTest.test1"); + byte[] payload = new byte[] { }; + SBPMessage sbp = new SBPMessage( 0xe0a2, 0xa1, payload ); + MsgSettingsSave msg = new MsgSettingsSave( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; diff --git a/java/test/auto_check_sbp_settings_MsgSettingsWriteRespTest.java b/java/test/auto_check_sbp_settings_MsgSettingsWriteRespTest.java index c88b749393517595d80ad134838616413325cc97..26c1e1231823c1835c88ec60ae0b97c83fd259a4 100644 GIT binary patch delta 814 zcmcbhuwR5lUyDm&BBKPO;YO(=jFay&x=vPQiV;-E%}>cpt5is;RLDroOHt&S{EwYbEZYce0R?Br=os*`syS!{M>j%Tb_$V)8;YA#8Q zj#a4E05LQTO^tM*EJITm%fJxIvb2N=8JfXZ25@DDFlB~@22fcOgd|MJ(j2C<-T-bK z+y>tctH_G9$mnWLthkE(Ktc^-<6S!pSN8ZvdBN=otV2 literal 4176 zcmeHK?QWw+6wPlx#a&BL?A8I}#NB42l}c>V&^llN*>qJ^5yk_aES_P6(tl zB1{m7dCtZ_Ss{#RO5kW<_bkV^j$kpN(FCTskP2@^U`&O~=qQ(Dj5rBFpbQpNPSE=) zm^#!F=|3EB8vtyZH`wNNkf_AiFlL<5yM;2KK>bnnjk(fqSE!!le6>>Lj zp!=ZN+?vrN5M=Uy%DF6mg_d%bd{Q&qo~_EX93eJJ;ci-_l&{pio@RmEdP3MvX!Vy+ h0paj+C+bM?)f(V0_hm*28>dSL=iev`e5^gz{s2B4---YL diff --git a/java/test/auto_check_sbp_settings_MsgSettingsWriteTest.java b/java/test/auto_check_sbp_settings_MsgSettingsWriteTest.java index 1a146a6f72b4ca91ff996934bbcc40bd5f18a163..b39bd5336e6748f73b65dfcdd37bbbf951ff07b2 100644 GIT binary patch delta 559 zcmbOtwt}BUUyDm&BBKPO;YO(=jFay&x=vPQO0reRNX$!7wWtHY-mgt3~7MECaO@7HFJ9!e5DiBLfKF=h*S%x{B zv0foBwOk>ovLrP+R-sx0#LzS}G}VE!3=E+xOG}uLp&5*209R%RQ)Xyr0F^aCNWz3H z&EY!Xrq#o3fT_Y}yCK3-1PjS}xLyNe(yTYAhq)YX1QyRzWW5E{MM%Df2^kui3&Vp1 z;gHFbIdw!83@Xf%bbw@{fsR5!Vr5Q#Vv54#OPuDc3dKnU3X^%bwlgYBKFk#e00^6; A2LJ#7 literal 2836 zcmeHJ-*4MC5bm@7ikpF;^5E!4wyaBw0#j_I(Pm4Aq%13jA)qAMW-E!BNZB!p{O>y| zR-B}*JfJUom|i5^-S>Sw9?7HmJ&bv^t=V!VK_3s{#IjG1Ppp#@h&F5?!6$3BB$DwG zyfQU3P=HdBRKA9ll$CgGnxd&HUQ0tLL`l|0$_orsvGIxt5WJ~V3hJv#KG0Nx_ONvA_Y?xdj z`a#S9C(nVmzBV}lH5Ig8(@f>i4(-y5U>rIule)lHs1O`ro z{{y)8;>+MFhHEDb9Y1~#!3E;p!*8BH87Vp!1KbeYKjxtuMTiVS@MiO==T1h*KAv7p zJpUb>BZnWvF!g3$j8Sm_i0dL1(N4j0Bc(BO!|^2wI_KWhLs=ZFiOd&X?4u0epuvH; z6UN^7YU+eAzY6C;0Q)VNDLAcO-+Rn=9Uz>*%jJEE>ln`S-BK#z|Bl7qn+WpW|A5T0Ld0QR-@V)FyT;g z2?fvCVvAlSvLa>nou+B5P>bpFF-Pa~85IKadGpnnZY;+0VLU*1y)-@uUK+nffgiN1 z@u{yVnKa`2`Kg)&mnft;5%+U*ldfp`@dner>7+i(SYhFlrU5=X0wHk+rI2u*Q&K`k zlV%BTVL@_%$+UqrTjP|&E^@(2l0(K(pTfkQ#tw$t^w>Vds;T&2l*(g?HD|aT&}i#J z+z2(_2&^r>h@$w^hAJRifZpm4A56*|ZH1(T!5e8TcwG>w501(saa0aQFi@-F-)7z} zEqgG$PfJlJTS@=?3o5eBImzJd6I~Th(oGk%AE$D3kFF?&VB4p-)4uR@e#`FlpPlu( zZTqKwzjZ*~?w7Z1tC#=BL-hUdvsb9ozaZLp5O%a}Bk`(mC&iwSJRehma%|loCih$2M cjRE#ErGwYTi<;3g%eOuX=)+x7ciNry58^P#y8r+H diff --git a/java/test/auto_check_sbp_signing_MsgAesCmacSignatureTest.java b/java/test/auto_check_sbp_signing_MsgAesCmacSignatureTest.java index 36ca1657f..792db64e4 100644 --- a/java/test/auto_check_sbp_signing_MsgAesCmacSignatureTest.java +++ b/java/test/auto_check_sbp_signing_MsgAesCmacSignatureTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/signing/test_MsgAesCmacSignature.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/signing/test_MsgAesCmacSignature.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.signing.MsgAesCmacSignature; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_signing_MsgAesCmacSignatureTest { @@ -30,23 +34,15 @@ public class auto_check_sbp_signing_MsgAesCmacSignatureTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_signing_MsgAesCmacSignatureTest.test1"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 2, (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 0, (byte) 1, - (byte) 2, (byte) 3, (byte) 4, (byte) 5, (byte) 6, (byte) 7, (byte) 8, (byte) 9, - (byte) 10, (byte) 11, (byte) 12, (byte) 13, (byte) 14, (byte) 15, (byte) 0, - (byte) 11, (byte) 22, (byte) 33, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xC10, payload); - MsgAesCmacSignature msg = new MsgAesCmacSignature(sbp); + byte[] payload = new byte[] {(byte)1,(byte)2,(byte)1,(byte)2,(byte)3,(byte)4,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)8,(byte)9,(byte)10,(byte)11,(byte)12,(byte)13,(byte)14,(byte)15,(byte)0,(byte)11,(byte)22,(byte)33, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xC10, payload ); + MsgAesCmacSignature msg = new MsgAesCmacSignature( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.certificate_id[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[0] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[0] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -54,9 +50,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[1] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[1] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -64,9 +58,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[2] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[2] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -74,9 +66,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[3] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[3] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -84,8 +74,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -93,9 +82,7 @@ public void test1() throws Throwable { } value = msg.on_demand_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.on_demand_counter + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.on_demand_counter + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -103,9 +90,7 @@ public void test1() throws Throwable { } value = msg.signature[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -113,9 +98,7 @@ public void test1() throws Throwable { } value = msg.signature[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[1] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[1] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -123,9 +106,7 @@ public void test1() throws Throwable { } value = msg.signature[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[2] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[2] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -133,9 +114,7 @@ public void test1() throws Throwable { } value = msg.signature[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[3] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[3] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -143,9 +122,7 @@ public void test1() throws Throwable { } value = msg.signature[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[4] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[4] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -153,9 +130,7 @@ public void test1() throws Throwable { } value = msg.signature[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[5] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[5] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -163,9 +138,7 @@ public void test1() throws Throwable { } value = msg.signature[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[6] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[6] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -173,9 +146,7 @@ public void test1() throws Throwable { } value = msg.signature[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[7] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[7] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -183,9 +154,7 @@ public void test1() throws Throwable { } value = msg.signature[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[8] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.signature[8] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -193,9 +162,7 @@ public void test1() throws Throwable { } value = msg.signature[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[9] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.signature[9] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -203,9 +170,7 @@ public void test1() throws Throwable { } value = msg.signature[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[10] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.signature[10] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -213,9 +178,7 @@ public void test1() throws Throwable { } value = msg.signature[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[11] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.signature[11] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -223,9 +186,7 @@ public void test1() throws Throwable { } value = msg.signature[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[12] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.signature[12] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -233,9 +194,7 @@ public void test1() throws Throwable { } value = msg.signature[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[13] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.signature[13] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -243,9 +202,7 @@ public void test1() throws Throwable { } value = msg.signature[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[14] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.signature[14] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -253,9 +210,7 @@ public void test1() throws Throwable { } value = msg.signature[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[15] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.signature[15] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -263,9 +218,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[0] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[0] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -273,9 +226,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[1] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[1] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -283,9 +234,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[2] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[2] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -293,9 +242,7 @@ public void test1() throws Throwable { } value = msg.stream_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stream_counter + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.stream_counter + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; diff --git a/java/test/auto_check_sbp_signing_MsgCertificateChainDepTest.java b/java/test/auto_check_sbp_signing_MsgCertificateChainDepTest.java index 33a457e36..50f35422c 100644 --- a/java/test/auto_check_sbp_signing_MsgCertificateChainDepTest.java +++ b/java/test/auto_check_sbp_signing_MsgCertificateChainDepTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/signing/test_MsgCertificateChainDep.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/signing/test_MsgCertificateChainDep.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.signing.MsgCertificateChainDep; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_signing_MsgCertificateChainDepTest { @@ -30,154 +34,15 @@ public class auto_check_sbp_signing_MsgCertificateChainDepTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_signing_MsgCertificateChainDepTest.test1"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 8, - (byte) 9, - (byte) 10, - (byte) 11, - (byte) 12, - (byte) 13, - (byte) 14, - (byte) 15, - (byte) 16, - (byte) 17, - (byte) 18, - (byte) 19, - (byte) 10, - (byte) 11, - (byte) 12, - (byte) 13, - (byte) 14, - (byte) 15, - (byte) 16, - (byte) 17, - (byte) 18, - (byte) 19, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 8, - (byte) 9, - (byte) 20, - (byte) 21, - (byte) 22, - (byte) 23, - (byte) 24, - (byte) 25, - (byte) 26, - (byte) 27, - (byte) 28, - (byte) 29, - (byte) 10, - (byte) 11, - (byte) 12, - (byte) 13, - (byte) 14, - (byte) 15, - (byte) 16, - (byte) 17, - (byte) 18, - (byte) 19, - (byte) 232, - (byte) 7, - (byte) 3, - (byte) 30, - (byte) 12, - (byte) 34, - (byte) 59, - (byte) 21, - (byte) 205, - (byte) 91, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xC05, payload); - MsgCertificateChainDep msg = new MsgCertificateChainDep(sbp); + byte[] payload = new byte[] {(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)8,(byte)9,(byte)10,(byte)11,(byte)12,(byte)13,(byte)14,(byte)15,(byte)16,(byte)17,(byte)18,(byte)19,(byte)10,(byte)11,(byte)12,(byte)13,(byte)14,(byte)15,(byte)16,(byte)17,(byte)18,(byte)19,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)8,(byte)9,(byte)20,(byte)21,(byte)22,(byte)23,(byte)24,(byte)25,(byte)26,(byte)27,(byte)28,(byte)29,(byte)10,(byte)11,(byte)12,(byte)13,(byte)14,(byte)15,(byte)16,(byte)17,(byte)18,(byte)19,(byte)232,(byte)7,(byte)3,(byte)30,(byte)12,(byte)34,(byte)59,(byte)21,(byte)205,(byte)91,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xC05, payload ); + MsgCertificateChainDep msg = new MsgCertificateChainDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.corrections_certificate[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[0] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[0] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -185,9 +50,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[1] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[1] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -195,9 +58,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[2] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[2] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -205,9 +66,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[3] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[3] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -215,9 +74,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[4] + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[4] + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -225,9 +82,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[5] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[5] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -235,9 +90,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[6] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[6] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -245,9 +98,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[7] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[7] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -255,9 +106,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[8] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[8] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -265,9 +114,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[9] + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[9] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -275,9 +122,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[10] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[10] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -285,9 +130,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[11] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[11] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -295,9 +138,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[12] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[12] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -305,9 +146,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[13] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[13] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -315,9 +154,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[14] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[14] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -325,9 +162,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[15] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[15] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -335,9 +170,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[16] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[16] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -345,9 +178,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[17] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[17] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -355,9 +186,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[18] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[18] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -365,9 +194,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[19] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[19] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -375,9 +202,7 @@ public void test1() throws Throwable { } value = msg.expiration.day; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.day + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.expiration.day + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -385,9 +210,7 @@ public void test1() throws Throwable { } value = msg.expiration.hours; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.hours + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.expiration.hours + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -395,9 +218,7 @@ public void test1() throws Throwable { } value = msg.expiration.minutes; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.minutes + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.expiration.minutes + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -405,9 +226,7 @@ public void test1() throws Throwable { } value = msg.expiration.month; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.month + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.expiration.month + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -415,9 +234,7 @@ public void test1() throws Throwable { } value = msg.expiration.ns; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.ns + "' != '" + 123456789 + "'", - value.equals(BigInteger.valueOf(123456789L))); + org.junit.Assert.assertTrue("'" + msg.expiration.ns + "' != '" + 123456789 + "'", value.equals(BigInteger.valueOf( 123456789L ) ) ); } else { value = value.longValue(); expected = 123456789L; @@ -425,9 +242,7 @@ public void test1() throws Throwable { } value = msg.expiration.seconds; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.seconds + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.expiration.seconds + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -435,9 +250,7 @@ public void test1() throws Throwable { } value = msg.expiration.year; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.year + "' != '" + 2024 + "'", - value.equals(BigInteger.valueOf(2024L))); + org.junit.Assert.assertTrue("'" + msg.expiration.year + "' != '" + 2024 + "'", value.equals(BigInteger.valueOf( 2024L ) ) ); } else { value = value.longValue(); expected = 2024L; @@ -445,9 +258,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[0] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[0] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -455,9 +266,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[1] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[1] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -465,9 +274,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[2] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[2] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -475,9 +282,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[3] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[3] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -485,9 +290,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[4] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[4] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -495,9 +298,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[5] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[5] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -505,9 +306,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[6] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[6] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -515,9 +314,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[7] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[7] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -525,9 +322,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[8] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[8] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -535,9 +330,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[9] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[9] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -545,9 +338,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[10] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[10] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -555,9 +346,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[11] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[11] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -565,9 +354,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[12] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[12] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -575,9 +362,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[13] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[13] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -585,9 +370,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[14] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[14] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -595,9 +378,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[15] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[15] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -605,9 +386,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[16] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[16] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -615,9 +394,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[17] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[17] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -625,9 +402,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[18] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[18] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -635,9 +410,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[19] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[19] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -645,9 +418,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -655,9 +426,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[1] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[1] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -665,9 +434,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[2] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[2] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -675,9 +442,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[3] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[3] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -685,9 +450,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[4] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[4] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -695,9 +458,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[5] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[5] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -705,9 +466,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[6] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[6] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -715,9 +474,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[7] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[7] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -725,9 +482,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[8] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[8] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -735,9 +490,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[9] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[9] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -745,9 +498,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[10] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[10] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -755,9 +506,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[11] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[11] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -765,9 +514,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[12] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[12] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -775,9 +522,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[13] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[13] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -785,9 +530,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[14] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[14] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -795,9 +538,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[15] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[15] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -805,9 +546,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[16] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[16] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -815,9 +554,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[17] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[17] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -825,9 +562,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[18] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[18] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -835,9 +570,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[19] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[19] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -845,9 +578,7 @@ public void test1() throws Throwable { } value = msg.signature[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -855,9 +586,7 @@ public void test1() throws Throwable { } value = msg.signature[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[1] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[1] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -865,9 +594,7 @@ public void test1() throws Throwable { } value = msg.signature[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[2] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[2] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -875,9 +602,7 @@ public void test1() throws Throwable { } value = msg.signature[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[3] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[3] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -885,9 +610,7 @@ public void test1() throws Throwable { } value = msg.signature[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[4] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[4] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -895,9 +618,7 @@ public void test1() throws Throwable { } value = msg.signature[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[5] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[5] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -905,9 +626,7 @@ public void test1() throws Throwable { } value = msg.signature[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[6] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[6] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -915,9 +634,7 @@ public void test1() throws Throwable { } value = msg.signature[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[7] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[7] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -925,9 +642,7 @@ public void test1() throws Throwable { } value = msg.signature[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[8] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[8] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -935,9 +650,7 @@ public void test1() throws Throwable { } value = msg.signature[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[9] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[9] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -945,9 +658,7 @@ public void test1() throws Throwable { } value = msg.signature[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[10] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[10] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -955,9 +666,7 @@ public void test1() throws Throwable { } value = msg.signature[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[11] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[11] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -965,9 +674,7 @@ public void test1() throws Throwable { } value = msg.signature[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[12] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[12] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -975,9 +682,7 @@ public void test1() throws Throwable { } value = msg.signature[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[13] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[13] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -985,9 +690,7 @@ public void test1() throws Throwable { } value = msg.signature[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[14] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[14] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -995,9 +698,7 @@ public void test1() throws Throwable { } value = msg.signature[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[15] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[15] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -1005,9 +706,7 @@ public void test1() throws Throwable { } value = msg.signature[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[16] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[16] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1015,9 +714,7 @@ public void test1() throws Throwable { } value = msg.signature[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[17] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[17] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1025,9 +722,7 @@ public void test1() throws Throwable { } value = msg.signature[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[18] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[18] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1035,9 +730,7 @@ public void test1() throws Throwable { } value = msg.signature[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[19] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[19] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1045,9 +738,7 @@ public void test1() throws Throwable { } value = msg.signature[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[20] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[20] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1055,9 +746,7 @@ public void test1() throws Throwable { } value = msg.signature[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[21] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[21] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -1065,9 +754,7 @@ public void test1() throws Throwable { } value = msg.signature[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[22] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[22] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1075,9 +762,7 @@ public void test1() throws Throwable { } value = msg.signature[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[23] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[23] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -1085,9 +770,7 @@ public void test1() throws Throwable { } value = msg.signature[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[24] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[24] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1095,9 +778,7 @@ public void test1() throws Throwable { } value = msg.signature[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[25] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[25] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1105,9 +786,7 @@ public void test1() throws Throwable { } value = msg.signature[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[26] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[26] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1115,9 +794,7 @@ public void test1() throws Throwable { } value = msg.signature[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[27] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[27] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1125,9 +802,7 @@ public void test1() throws Throwable { } value = msg.signature[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[28] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[28] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1135,9 +810,7 @@ public void test1() throws Throwable { } value = msg.signature[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[29] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[29] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -1145,9 +818,7 @@ public void test1() throws Throwable { } value = msg.signature[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[30] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[30] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1155,9 +826,7 @@ public void test1() throws Throwable { } value = msg.signature[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[31] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[31] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -1165,9 +834,7 @@ public void test1() throws Throwable { } value = msg.signature[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[32] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[32] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1175,9 +842,7 @@ public void test1() throws Throwable { } value = msg.signature[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[33] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[33] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1185,9 +850,7 @@ public void test1() throws Throwable { } value = msg.signature[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[34] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[34] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1195,9 +858,7 @@ public void test1() throws Throwable { } value = msg.signature[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[35] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[35] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1205,9 +866,7 @@ public void test1() throws Throwable { } value = msg.signature[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[36] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[36] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1215,9 +874,7 @@ public void test1() throws Throwable { } value = msg.signature[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[37] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[37] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -1225,9 +882,7 @@ public void test1() throws Throwable { } value = msg.signature[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[38] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[38] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1235,9 +890,7 @@ public void test1() throws Throwable { } value = msg.signature[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[39] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[39] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -1245,9 +898,7 @@ public void test1() throws Throwable { } value = msg.signature[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[40] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[40] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1255,9 +906,7 @@ public void test1() throws Throwable { } value = msg.signature[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[41] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[41] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1265,9 +914,7 @@ public void test1() throws Throwable { } value = msg.signature[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[42] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[42] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1275,9 +922,7 @@ public void test1() throws Throwable { } value = msg.signature[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[43] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[43] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1285,9 +930,7 @@ public void test1() throws Throwable { } value = msg.signature[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[44] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[44] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1295,9 +938,7 @@ public void test1() throws Throwable { } value = msg.signature[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[45] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[45] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -1305,9 +946,7 @@ public void test1() throws Throwable { } value = msg.signature[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[46] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[46] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1315,9 +954,7 @@ public void test1() throws Throwable { } value = msg.signature[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[47] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[47] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -1325,9 +962,7 @@ public void test1() throws Throwable { } value = msg.signature[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[48] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[48] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1335,9 +970,7 @@ public void test1() throws Throwable { } value = msg.signature[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[49] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[49] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1345,9 +978,7 @@ public void test1() throws Throwable { } value = msg.signature[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[50] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[50] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1355,9 +986,7 @@ public void test1() throws Throwable { } value = msg.signature[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[51] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[51] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1365,9 +994,7 @@ public void test1() throws Throwable { } value = msg.signature[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[52] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[52] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1375,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.signature[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[53] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[53] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -1385,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.signature[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[54] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[54] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1395,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.signature[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[55] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[55] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -1405,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.signature[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[56] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[56] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1415,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.signature[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[57] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[57] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1425,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.signature[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[58] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[58] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1435,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.signature[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[59] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[59] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1445,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.signature[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[60] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[60] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1455,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.signature[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[61] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[61] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -1465,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.signature[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[62] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[62] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1475,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.signature[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[63] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[63] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; diff --git a/java/test/auto_check_sbp_signing_MsgCertificateChainTest.java b/java/test/auto_check_sbp_signing_MsgCertificateChainTest.java index 6e0e6516c..5eb59af29 100644 --- a/java/test/auto_check_sbp_signing_MsgCertificateChainTest.java +++ b/java/test/auto_check_sbp_signing_MsgCertificateChainTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/signing/test_MsgCertificateChain.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/signing/test_MsgCertificateChain.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.signing.MsgCertificateChain; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_signing_MsgCertificateChainTest { @@ -30,163 +34,15 @@ public class auto_check_sbp_signing_MsgCertificateChainTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_signing_MsgCertificateChainTest.test1"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 8, - (byte) 9, - (byte) 10, - (byte) 11, - (byte) 12, - (byte) 13, - (byte) 14, - (byte) 15, - (byte) 16, - (byte) 17, - (byte) 18, - (byte) 19, - (byte) 10, - (byte) 11, - (byte) 12, - (byte) 13, - (byte) 14, - (byte) 15, - (byte) 16, - (byte) 17, - (byte) 18, - (byte) 19, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 8, - (byte) 9, - (byte) 20, - (byte) 21, - (byte) 22, - (byte) 23, - (byte) 24, - (byte) 25, - (byte) 26, - (byte) 27, - (byte) 28, - (byte) 29, - (byte) 10, - (byte) 11, - (byte) 12, - (byte) 13, - (byte) 14, - (byte) 15, - (byte) 16, - (byte) 17, - (byte) 18, - (byte) 19, - (byte) 232, - (byte) 7, - (byte) 3, - (byte) 30, - (byte) 12, - (byte) 34, - (byte) 59, - (byte) 21, - (byte) 205, - (byte) 91, - (byte) 7, - (byte) 72, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 8, - (byte) 9, - (byte) 10, - (byte) 11, - (byte) 12, - (byte) 13, - (byte) 14, - (byte) 15, - (byte) 16, - (byte) 17, - (byte) 18, - (byte) 19, - (byte) 20, - (byte) 21, - (byte) 22, - (byte) 23, - (byte) 24, - (byte) 25, - (byte) 26, - (byte) 27, - (byte) 28, - (byte) 29, - (byte) 30, - (byte) 31, - (byte) 32, - (byte) 33, - (byte) 34, - (byte) 35, - (byte) 36, - (byte) 37, - (byte) 38, - (byte) 39, - (byte) 40, - (byte) 41, - (byte) 42, - (byte) 43, - (byte) 44, - (byte) 45, - (byte) 46, - (byte) 47, - (byte) 48, - (byte) 49, - (byte) 50, - (byte) 51, - (byte) 52, - (byte) 53, - (byte) 54, - (byte) 55, - (byte) 56, - (byte) 57, - (byte) 58, - (byte) 59, - (byte) 60, - (byte) 61, - (byte) 62, - (byte) 63, - (byte) 64, - (byte) 65, - (byte) 66, - (byte) 67, - (byte) 68, - (byte) 69, - (byte) 70, - (byte) 71, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xC09, payload); - MsgCertificateChain msg = new MsgCertificateChain(sbp); + byte[] payload = new byte[] {(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)8,(byte)9,(byte)10,(byte)11,(byte)12,(byte)13,(byte)14,(byte)15,(byte)16,(byte)17,(byte)18,(byte)19,(byte)10,(byte)11,(byte)12,(byte)13,(byte)14,(byte)15,(byte)16,(byte)17,(byte)18,(byte)19,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)8,(byte)9,(byte)20,(byte)21,(byte)22,(byte)23,(byte)24,(byte)25,(byte)26,(byte)27,(byte)28,(byte)29,(byte)10,(byte)11,(byte)12,(byte)13,(byte)14,(byte)15,(byte)16,(byte)17,(byte)18,(byte)19,(byte)232,(byte)7,(byte)3,(byte)30,(byte)12,(byte)34,(byte)59,(byte)21,(byte)205,(byte)91,(byte)7,(byte)72,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)8,(byte)9,(byte)10,(byte)11,(byte)12,(byte)13,(byte)14,(byte)15,(byte)16,(byte)17,(byte)18,(byte)19,(byte)20,(byte)21,(byte)22,(byte)23,(byte)24,(byte)25,(byte)26,(byte)27,(byte)28,(byte)29,(byte)30,(byte)31,(byte)32,(byte)33,(byte)34,(byte)35,(byte)36,(byte)37,(byte)38,(byte)39,(byte)40,(byte)41,(byte)42,(byte)43,(byte)44,(byte)45,(byte)46,(byte)47,(byte)48,(byte)49,(byte)50,(byte)51,(byte)52,(byte)53,(byte)54,(byte)55,(byte)56,(byte)57,(byte)58,(byte)59,(byte)60,(byte)61,(byte)62,(byte)63,(byte)64,(byte)65,(byte)66,(byte)67,(byte)68,(byte)69,(byte)70,(byte)71, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xC09, payload ); + MsgCertificateChain msg = new MsgCertificateChain( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.corrections_certificate[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[0] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[0] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -194,9 +50,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[1] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[1] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -204,9 +58,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[2] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[2] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -214,9 +66,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[3] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[3] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -224,9 +74,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[4] + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[4] + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -234,9 +82,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[5] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[5] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -244,9 +90,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[6] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[6] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -254,9 +98,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[7] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[7] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -264,9 +106,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[8] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[8] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -274,9 +114,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[9] + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[9] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -284,9 +122,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[10] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[10] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -294,9 +130,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[11] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[11] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -304,9 +138,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[12] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[12] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -314,9 +146,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[13] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[13] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -324,9 +154,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[14] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[14] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -334,9 +162,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[15] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[15] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -344,9 +170,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[16] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[16] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -354,9 +178,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[17] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[17] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -364,9 +186,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[18] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[18] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -374,9 +194,7 @@ public void test1() throws Throwable { } value = msg.corrections_certificate[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrections_certificate[19] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.corrections_certificate[19] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -384,9 +202,7 @@ public void test1() throws Throwable { } value = msg.expiration.day; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.day + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.expiration.day + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -394,9 +210,7 @@ public void test1() throws Throwable { } value = msg.expiration.hours; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.hours + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.expiration.hours + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -404,9 +218,7 @@ public void test1() throws Throwable { } value = msg.expiration.minutes; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.minutes + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.expiration.minutes + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -414,9 +226,7 @@ public void test1() throws Throwable { } value = msg.expiration.month; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.month + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.expiration.month + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -424,9 +234,7 @@ public void test1() throws Throwable { } value = msg.expiration.ns; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.ns + "' != '" + 123456789 + "'", - value.equals(BigInteger.valueOf(123456789L))); + org.junit.Assert.assertTrue("'" + msg.expiration.ns + "' != '" + 123456789 + "'", value.equals(BigInteger.valueOf( 123456789L ) ) ); } else { value = value.longValue(); expected = 123456789L; @@ -434,9 +242,7 @@ public void test1() throws Throwable { } value = msg.expiration.seconds; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.seconds + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.expiration.seconds + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -444,9 +250,7 @@ public void test1() throws Throwable { } value = msg.expiration.year; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.expiration.year + "' != '" + 2024 + "'", - value.equals(BigInteger.valueOf(2024L))); + org.junit.Assert.assertTrue("'" + msg.expiration.year + "' != '" + 2024 + "'", value.equals(BigInteger.valueOf( 2024L ) ) ); } else { value = value.longValue(); expected = 2024L; @@ -454,9 +258,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[0] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[0] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -464,9 +266,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[1] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[1] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -474,9 +274,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[2] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[2] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -484,9 +282,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[3] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[3] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -494,9 +290,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[4] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[4] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -504,9 +298,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[5] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[5] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -514,9 +306,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[6] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[6] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -524,9 +314,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[7] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[7] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -534,9 +322,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[8] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[8] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -544,9 +330,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[9] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[9] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -554,9 +338,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[10] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[10] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -564,9 +346,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[11] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[11] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -574,9 +354,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[12] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[12] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -584,9 +362,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[13] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[13] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -594,9 +370,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[14] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[14] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -604,9 +378,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[15] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[15] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -614,9 +386,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[16] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[16] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -624,9 +394,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[17] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[17] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -634,9 +402,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[18] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[18] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -644,9 +410,7 @@ public void test1() throws Throwable { } value = msg.intermediate_certificate[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.intermediate_certificate[19] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.intermediate_certificate[19] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -654,9 +418,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -664,9 +426,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[1] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[1] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -674,9 +434,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[2] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[2] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -684,9 +442,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[3] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[3] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -694,9 +450,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[4] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[4] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -704,9 +458,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[5] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[5] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -714,9 +466,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[6] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[6] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -724,9 +474,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[7] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[7] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -734,9 +482,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[8] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[8] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -744,9 +490,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[9] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[9] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -754,9 +498,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[10] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[10] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -764,9 +506,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[11] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[11] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -774,9 +514,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[12] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[12] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -784,9 +522,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[13] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[13] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -794,9 +530,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[14] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[14] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -804,9 +538,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[15] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[15] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -814,9 +546,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[16] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[16] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -824,9 +554,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[17] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[17] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -834,9 +562,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[18] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[18] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -844,9 +570,7 @@ public void test1() throws Throwable { } value = msg.root_certificate[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.root_certificate[19] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.root_certificate[19] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -854,9 +578,7 @@ public void test1() throws Throwable { } value = msg.signature.data[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -864,9 +586,7 @@ public void test1() throws Throwable { } value = msg.signature.data[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[1] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[1] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -874,9 +594,7 @@ public void test1() throws Throwable { } value = msg.signature.data[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[2] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[2] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -884,9 +602,7 @@ public void test1() throws Throwable { } value = msg.signature.data[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[3] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[3] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -894,9 +610,7 @@ public void test1() throws Throwable { } value = msg.signature.data[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[4] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[4] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -904,9 +618,7 @@ public void test1() throws Throwable { } value = msg.signature.data[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[5] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[5] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -914,9 +626,7 @@ public void test1() throws Throwable { } value = msg.signature.data[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[6] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[6] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -924,9 +634,7 @@ public void test1() throws Throwable { } value = msg.signature.data[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[7] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[7] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -934,9 +642,7 @@ public void test1() throws Throwable { } value = msg.signature.data[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[8] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[8] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -944,9 +650,7 @@ public void test1() throws Throwable { } value = msg.signature.data[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[9] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[9] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -954,9 +658,7 @@ public void test1() throws Throwable { } value = msg.signature.data[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[10] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[10] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -964,9 +666,7 @@ public void test1() throws Throwable { } value = msg.signature.data[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[11] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[11] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -974,9 +674,7 @@ public void test1() throws Throwable { } value = msg.signature.data[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[12] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[12] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -984,9 +682,7 @@ public void test1() throws Throwable { } value = msg.signature.data[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[13] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[13] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -994,9 +690,7 @@ public void test1() throws Throwable { } value = msg.signature.data[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[14] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[14] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -1004,9 +698,7 @@ public void test1() throws Throwable { } value = msg.signature.data[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[15] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[15] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -1014,9 +706,7 @@ public void test1() throws Throwable { } value = msg.signature.data[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[16] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[16] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -1024,9 +714,7 @@ public void test1() throws Throwable { } value = msg.signature.data[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[17] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[17] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -1034,9 +722,7 @@ public void test1() throws Throwable { } value = msg.signature.data[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[18] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[18] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -1044,9 +730,7 @@ public void test1() throws Throwable { } value = msg.signature.data[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[19] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[19] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -1054,9 +738,7 @@ public void test1() throws Throwable { } value = msg.signature.data[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[20] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[20] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -1064,9 +746,7 @@ public void test1() throws Throwable { } value = msg.signature.data[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[21] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[21] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -1074,9 +754,7 @@ public void test1() throws Throwable { } value = msg.signature.data[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[22] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[22] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -1084,9 +762,7 @@ public void test1() throws Throwable { } value = msg.signature.data[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[23] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[23] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1094,9 +770,7 @@ public void test1() throws Throwable { } value = msg.signature.data[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[24] + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[24] + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -1104,9 +778,7 @@ public void test1() throws Throwable { } value = msg.signature.data[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[25] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[25] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -1114,9 +786,7 @@ public void test1() throws Throwable { } value = msg.signature.data[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[26] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[26] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -1124,9 +794,7 @@ public void test1() throws Throwable { } value = msg.signature.data[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[27] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[27] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -1134,9 +802,7 @@ public void test1() throws Throwable { } value = msg.signature.data[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[28] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[28] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -1144,9 +810,7 @@ public void test1() throws Throwable { } value = msg.signature.data[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[29] + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[29] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -1154,9 +818,7 @@ public void test1() throws Throwable { } value = msg.signature.data[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[30] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[30] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -1164,9 +826,7 @@ public void test1() throws Throwable { } value = msg.signature.data[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[31] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[31] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -1174,9 +834,7 @@ public void test1() throws Throwable { } value = msg.signature.data[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[32] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[32] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -1184,9 +842,7 @@ public void test1() throws Throwable { } value = msg.signature.data[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[33] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[33] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -1194,9 +850,7 @@ public void test1() throws Throwable { } value = msg.signature.data[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[34] + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[34] + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -1204,9 +858,7 @@ public void test1() throws Throwable { } value = msg.signature.data[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[35] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[35] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -1214,9 +866,7 @@ public void test1() throws Throwable { } value = msg.signature.data[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[36] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[36] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -1224,9 +874,7 @@ public void test1() throws Throwable { } value = msg.signature.data[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[37] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[37] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -1234,9 +882,7 @@ public void test1() throws Throwable { } value = msg.signature.data[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[38] + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[38] + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -1244,9 +890,7 @@ public void test1() throws Throwable { } value = msg.signature.data[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[39] + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[39] + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -1254,9 +898,7 @@ public void test1() throws Throwable { } value = msg.signature.data[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[40] + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[40] + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -1264,9 +906,7 @@ public void test1() throws Throwable { } value = msg.signature.data[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[41] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[41] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -1274,9 +914,7 @@ public void test1() throws Throwable { } value = msg.signature.data[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[42] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[42] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -1284,9 +922,7 @@ public void test1() throws Throwable { } value = msg.signature.data[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[43] + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[43] + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -1294,9 +930,7 @@ public void test1() throws Throwable { } value = msg.signature.data[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[44] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[44] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -1304,9 +938,7 @@ public void test1() throws Throwable { } value = msg.signature.data[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[45] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[45] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -1314,9 +946,7 @@ public void test1() throws Throwable { } value = msg.signature.data[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[46] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[46] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -1324,9 +954,7 @@ public void test1() throws Throwable { } value = msg.signature.data[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[47] + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[47] + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -1334,9 +962,7 @@ public void test1() throws Throwable { } value = msg.signature.data[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[48] + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[48] + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -1344,9 +970,7 @@ public void test1() throws Throwable { } value = msg.signature.data[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[49] + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[49] + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -1354,9 +978,7 @@ public void test1() throws Throwable { } value = msg.signature.data[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[50] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[50] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -1364,9 +986,7 @@ public void test1() throws Throwable { } value = msg.signature.data[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[51] + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[51] + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -1374,9 +994,7 @@ public void test1() throws Throwable { } value = msg.signature.data[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[52] + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[52] + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -1384,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.signature.data[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[53] + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[53] + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -1394,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.signature.data[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[54] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[54] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -1404,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.signature.data[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[55] + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[55] + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -1414,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.signature.data[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[56] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[56] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -1424,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.signature.data[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[57] + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[57] + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -1434,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.signature.data[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[58] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[58] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -1444,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.signature.data[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[59] + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[59] + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -1454,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.signature.data[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[60] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[60] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -1464,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.signature.data[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[61] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[61] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -1474,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.signature.data[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[62] + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[62] + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -1484,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.signature.data[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[63] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[63] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -1494,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.signature.data[64]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[64] + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[64] + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -1504,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.signature.data[65]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[65] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[65] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -1514,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.signature.data[66]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[66] + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[66] + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -1524,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.signature.data[67]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[67] + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[67] + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -1534,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.signature.data[68]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[68] + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[68] + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -1544,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.signature.data[69]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[69] + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[69] + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -1554,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.signature.data[70]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[70] + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[70] + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -1564,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.signature.data[71]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[71] + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[71] + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -1574,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.signature.len; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.len + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.signature.len + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; diff --git a/java/test/auto_check_sbp_signing_MsgEcdsaCertificateTest.java b/java/test/auto_check_sbp_signing_MsgEcdsaCertificateTest.java index 5f11117ef..416228f75 100644 --- a/java/test/auto_check_sbp_signing_MsgEcdsaCertificateTest.java +++ b/java/test/auto_check_sbp_signing_MsgEcdsaCertificateTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/signing/test_MsgEcdsaCertificate.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/signing/test_MsgEcdsaCertificate.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.signing.MsgEcdsaCertificate; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_signing_MsgEcdsaCertificateTest { @@ -30,272 +34,15 @@ public class auto_check_sbp_signing_MsgEcdsaCertificateTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_signing_MsgEcdsaCertificateTest.test1"); - byte[] payload = - new byte[] { - (byte) 48, - (byte) 10, - (byte) 11, - (byte) 12, - (byte) 13, - (byte) 2, - (byte) 180, - (byte) 160, - (byte) 116, - (byte) 77, - (byte) 243, - (byte) 28, - (byte) 173, - (byte) 36, - (byte) 86, - (byte) 33, - (byte) 8, - (byte) 31, - (byte) 120, - (byte) 73, - (byte) 64, - (byte) 169, - (byte) 148, - (byte) 224, - (byte) 57, - (byte) 95, - (byte) 17, - (byte) 40, - (byte) 213, - (byte) 92, - (byte) 195, - (byte) 146, - (byte) 235, - (byte) 228, - (byte) 177, - (byte) 101, - (byte) 82, - (byte) 182, - (byte) 25, - (byte) 172, - (byte) 170, - (byte) 250, - (byte) 236, - (byte) 7, - (byte) 119, - (byte) 4, - (byte) 201, - (byte) 10, - (byte) 14, - (byte) 208, - (byte) 47, - (byte) 126, - (byte) 49, - (byte) 210, - (byte) 174, - (byte) 75, - (byte) 221, - (byte) 203, - (byte) 24, - (byte) 66, - (byte) 52, - (byte) 35, - (byte) 26, - (byte) 30, - (byte) 140, - (byte) 111, - (byte) 246, - (byte) 39, - (byte) 226, - (byte) 205, - (byte) 198, - (byte) 178, - (byte) 196, - (byte) 5, - (byte) 81, - (byte) 9, - (byte) 44, - (byte) 164, - (byte) 163, - (byte) 214, - (byte) 138, - (byte) 123, - (byte) 76, - (byte) 74, - (byte) 237, - (byte) 121, - (byte) 13, - (byte) 137, - (byte) 186, - (byte) 97, - (byte) 193, - (byte) 189, - (byte) 200, - (byte) 124, - (byte) 69, - (byte) 115, - (byte) 230, - (byte) 159, - (byte) 185, - (byte) 158, - (byte) 51, - (byte) 12, - (byte) 225, - (byte) 65, - (byte) 192, - (byte) 105, - (byte) 56, - (byte) 41, - (byte) 85, - (byte) 133, - (byte) 19, - (byte) 217, - (byte) 166, - (byte) 48, - (byte) 139, - (byte) 131, - (byte) 96, - (byte) 216, - (byte) 98, - (byte) 147, - (byte) 132, - (byte) 234, - (byte) 167, - (byte) 248, - (byte) 247, - (byte) 32, - (byte) 239, - (byte) 194, - (byte) 188, - (byte) 254, - (byte) 114, - (byte) 117, - (byte) 83, - (byte) 25, - (byte) 251, - (byte) 191, - (byte) 104, - (byte) 240, - (byte) 118, - (byte) 68, - (byte) 42, - (byte) 93, - (byte) 18, - (byte) 16, - (byte) 37, - (byte) 232, - (byte) 99, - (byte) 179, - (byte) 23, - (byte) 90, - (byte) 94, - (byte) 136, - (byte) 6, - (byte) 125, - (byte) 91, - (byte) 255, - (byte) 15, - (byte) 71, - (byte) 43, - (byte) 46, - (byte) 25, - (byte) 252, - (byte) 229, - (byte) 80, - (byte) 143, - (byte) 58, - (byte) 241, - (byte) 11, - (byte) 62, - (byte) 181, - (byte) 155, - (byte) 53, - (byte) 153, - (byte) 149, - (byte) 152, - (byte) 227, - (byte) 150, - (byte) 87, - (byte) 112, - (byte) 165, - (byte) 2, - (byte) 128, - (byte) 231, - (byte) 25, - (byte) 157, - (byte) 244, - (byte) 204, - (byte) 108, - (byte) 253, - (byte) 127, - (byte) 122, - (byte) 145, - (byte) 113, - (byte) 162, - (byte) 197, - (byte) 171, - (byte) 199, - (byte) 54, - (byte) 184, - (byte) 222, - (byte) 206, - (byte) 67, - (byte) 144, - (byte) 78, - (byte) 187, - (byte) 207, - (byte) 60, - (byte) 211, - (byte) 141, - (byte) 135, - (byte) 106, - (byte) 220, - (byte) 79, - (byte) 183, - (byte) 245, - (byte) 21, - (byte) 161, - (byte) 168, - (byte) 34, - (byte) 129, - (byte) 50, - (byte) 176, - (byte) 1, - (byte) 218, - (byte) 20, - (byte) 130, - (byte) 59, - (byte) 249, - (byte) 109, - (byte) 219, - (byte) 0, - (byte) 100, - (byte) 103, - (byte) 55, - (byte) 29, - (byte) 242, - (byte) 110, - (byte) 154, - (byte) 190, - (byte) 233, - (byte) 142, - (byte) 45, - (byte) 61, - (byte) 215, - (byte) 202, - (byte) 238, - (byte) 88, - (byte) 209, - (byte) 70, - (byte) 63, - (byte) 151, - (byte) 27, - (byte) 102, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xC04, payload); - MsgEcdsaCertificate msg = new MsgEcdsaCertificate(sbp); + byte[] payload = new byte[] {(byte)48,(byte)10,(byte)11,(byte)12,(byte)13,(byte)2,(byte)180,(byte)160,(byte)116,(byte)77,(byte)243,(byte)28,(byte)173,(byte)36,(byte)86,(byte)33,(byte)8,(byte)31,(byte)120,(byte)73,(byte)64,(byte)169,(byte)148,(byte)224,(byte)57,(byte)95,(byte)17,(byte)40,(byte)213,(byte)92,(byte)195,(byte)146,(byte)235,(byte)228,(byte)177,(byte)101,(byte)82,(byte)182,(byte)25,(byte)172,(byte)170,(byte)250,(byte)236,(byte)7,(byte)119,(byte)4,(byte)201,(byte)10,(byte)14,(byte)208,(byte)47,(byte)126,(byte)49,(byte)210,(byte)174,(byte)75,(byte)221,(byte)203,(byte)24,(byte)66,(byte)52,(byte)35,(byte)26,(byte)30,(byte)140,(byte)111,(byte)246,(byte)39,(byte)226,(byte)205,(byte)198,(byte)178,(byte)196,(byte)5,(byte)81,(byte)9,(byte)44,(byte)164,(byte)163,(byte)214,(byte)138,(byte)123,(byte)76,(byte)74,(byte)237,(byte)121,(byte)13,(byte)137,(byte)186,(byte)97,(byte)193,(byte)189,(byte)200,(byte)124,(byte)69,(byte)115,(byte)230,(byte)159,(byte)185,(byte)158,(byte)51,(byte)12,(byte)225,(byte)65,(byte)192,(byte)105,(byte)56,(byte)41,(byte)85,(byte)133,(byte)19,(byte)217,(byte)166,(byte)48,(byte)139,(byte)131,(byte)96,(byte)216,(byte)98,(byte)147,(byte)132,(byte)234,(byte)167,(byte)248,(byte)247,(byte)32,(byte)239,(byte)194,(byte)188,(byte)254,(byte)114,(byte)117,(byte)83,(byte)25,(byte)251,(byte)191,(byte)104,(byte)240,(byte)118,(byte)68,(byte)42,(byte)93,(byte)18,(byte)16,(byte)37,(byte)232,(byte)99,(byte)179,(byte)23,(byte)90,(byte)94,(byte)136,(byte)6,(byte)125,(byte)91,(byte)255,(byte)15,(byte)71,(byte)43,(byte)46,(byte)25,(byte)252,(byte)229,(byte)80,(byte)143,(byte)58,(byte)241,(byte)11,(byte)62,(byte)181,(byte)155,(byte)53,(byte)153,(byte)149,(byte)152,(byte)227,(byte)150,(byte)87,(byte)112,(byte)165,(byte)2,(byte)128,(byte)231,(byte)25,(byte)157,(byte)244,(byte)204,(byte)108,(byte)253,(byte)127,(byte)122,(byte)145,(byte)113,(byte)162,(byte)197,(byte)171,(byte)199,(byte)54,(byte)184,(byte)222,(byte)206,(byte)67,(byte)144,(byte)78,(byte)187,(byte)207,(byte)60,(byte)211,(byte)141,(byte)135,(byte)106,(byte)220,(byte)79,(byte)183,(byte)245,(byte)21,(byte)161,(byte)168,(byte)34,(byte)129,(byte)50,(byte)176,(byte)1,(byte)218,(byte)20,(byte)130,(byte)59,(byte)249,(byte)109,(byte)219,(byte)0,(byte)100,(byte)103,(byte)55,(byte)29,(byte)242,(byte)110,(byte)154,(byte)190,(byte)233,(byte)142,(byte)45,(byte)61,(byte)215,(byte)202,(byte)238,(byte)88,(byte)209,(byte)70,(byte)63,(byte)151,(byte)27,(byte)102, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xC04, payload ); + MsgEcdsaCertificate msg = new MsgEcdsaCertificate( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.certificate_bytes[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[0] + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[0] + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -303,9 +50,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[1] + "' != '" + 160 + "'", - value.equals(BigInteger.valueOf(160L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[1] + "' != '" + 160 + "'", value.equals(BigInteger.valueOf( 160L ) ) ); } else { value = value.longValue(); expected = 160L; @@ -313,9 +58,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[2] + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[2] + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -323,9 +66,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[3] + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[3] + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -333,9 +74,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[4] + "' != '" + 243 + "'", - value.equals(BigInteger.valueOf(243L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[4] + "' != '" + 243 + "'", value.equals(BigInteger.valueOf( 243L ) ) ); } else { value = value.longValue(); expected = 243L; @@ -343,9 +82,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[5] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[5] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -353,9 +90,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[6] + "' != '" + 173 + "'", - value.equals(BigInteger.valueOf(173L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[6] + "' != '" + 173 + "'", value.equals(BigInteger.valueOf( 173L ) ) ); } else { value = value.longValue(); expected = 173L; @@ -363,9 +98,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[7] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[7] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -373,9 +106,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[8] + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[8] + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -383,9 +114,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[9] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[9] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -393,9 +122,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[10] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[10] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -403,9 +130,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[11] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[11] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -413,9 +138,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[12] + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[12] + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -423,9 +146,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[13] + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[13] + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -433,9 +154,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[14] + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[14] + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -443,9 +162,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[15] + "' != '" + 169 + "'", - value.equals(BigInteger.valueOf(169L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[15] + "' != '" + 169 + "'", value.equals(BigInteger.valueOf( 169L ) ) ); } else { value = value.longValue(); expected = 169L; @@ -453,9 +170,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[16] + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[16] + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -463,9 +178,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[17] + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[17] + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -473,9 +186,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[18] + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[18] + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -483,9 +194,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[19] + "' != '" + 95 + "'", - value.equals(BigInteger.valueOf(95L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[19] + "' != '" + 95 + "'", value.equals(BigInteger.valueOf( 95L ) ) ); } else { value = value.longValue(); expected = 95L; @@ -493,9 +202,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[20] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[20] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -503,9 +210,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[21] + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[21] + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -513,9 +218,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[22] + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[22] + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -523,9 +226,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[23] + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[23] + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -533,9 +234,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[24] + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[24] + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -543,9 +242,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[25] + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[25] + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -553,9 +250,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[26] + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[26] + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -563,9 +258,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[27] + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[27] + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -573,9 +266,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[28] + "' != '" + 177 + "'", - value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[28] + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -583,9 +274,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[29] + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[29] + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -593,9 +282,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[30] + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[30] + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -603,9 +290,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[31] + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[31] + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -613,9 +298,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[32] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[32] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -623,9 +306,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[33] + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[33] + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -633,9 +314,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[34] + "' != '" + 170 + "'", - value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[34] + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -643,9 +322,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[35] + "' != '" + 250 + "'", - value.equals(BigInteger.valueOf(250L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[35] + "' != '" + 250 + "'", value.equals(BigInteger.valueOf( 250L ) ) ); } else { value = value.longValue(); expected = 250L; @@ -653,9 +330,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[36] + "' != '" + 236 + "'", - value.equals(BigInteger.valueOf(236L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[36] + "' != '" + 236 + "'", value.equals(BigInteger.valueOf( 236L ) ) ); } else { value = value.longValue(); expected = 236L; @@ -663,9 +338,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[37] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[37] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -673,9 +346,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[38] + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[38] + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -683,9 +354,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[39] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[39] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -693,9 +362,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[40] + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[40] + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -703,9 +370,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[41] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[41] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -713,9 +378,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[42] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[42] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -723,9 +386,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[43] + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[43] + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -733,9 +394,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[44] + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[44] + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -743,9 +402,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[45] + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[45] + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -753,9 +410,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[46] + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[46] + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -763,9 +418,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[47] + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[47] + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -773,9 +426,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[48] + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[48] + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -783,9 +434,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[49] + "' != '" + 75 + "'", - value.equals(BigInteger.valueOf(75L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[49] + "' != '" + 75 + "'", value.equals(BigInteger.valueOf( 75L ) ) ); } else { value = value.longValue(); expected = 75L; @@ -793,9 +442,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[50] + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[50] + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -803,9 +450,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[51] + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[51] + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -813,9 +458,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[52] + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[52] + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -823,9 +466,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[53] + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[53] + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -833,9 +474,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[54] + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[54] + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -843,9 +482,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[55] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[55] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -853,9 +490,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[56] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[56] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -863,9 +498,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[57] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[57] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -873,9 +506,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[58] + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[58] + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -883,9 +514,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[59] + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[59] + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -893,9 +522,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[60] + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[60] + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -903,9 +530,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[61] + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[61] + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -913,9 +538,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[62] + "' != '" + 226 + "'", - value.equals(BigInteger.valueOf(226L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[62] + "' != '" + 226 + "'", value.equals(BigInteger.valueOf( 226L ) ) ); } else { value = value.longValue(); expected = 226L; @@ -923,9 +546,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[63] + "' != '" + 205 + "'", - value.equals(BigInteger.valueOf(205L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[63] + "' != '" + 205 + "'", value.equals(BigInteger.valueOf( 205L ) ) ); } else { value = value.longValue(); expected = 205L; @@ -933,9 +554,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[64]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[64] + "' != '" + 198 + "'", - value.equals(BigInteger.valueOf(198L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[64] + "' != '" + 198 + "'", value.equals(BigInteger.valueOf( 198L ) ) ); } else { value = value.longValue(); expected = 198L; @@ -943,9 +562,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[65]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[65] + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[65] + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -953,9 +570,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[66]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[66] + "' != '" + 196 + "'", - value.equals(BigInteger.valueOf(196L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[66] + "' != '" + 196 + "'", value.equals(BigInteger.valueOf( 196L ) ) ); } else { value = value.longValue(); expected = 196L; @@ -963,9 +578,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[67]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[67] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[67] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -973,9 +586,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[68]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[68] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[68] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -983,9 +594,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[69]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[69] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[69] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -993,9 +602,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[70]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[70] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[70] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -1003,9 +610,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[71]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[71] + "' != '" + 164 + "'", - value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[71] + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -1013,9 +618,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[72]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[72] + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[72] + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -1023,9 +626,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[73]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[73] + "' != '" + 214 + "'", - value.equals(BigInteger.valueOf(214L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[73] + "' != '" + 214 + "'", value.equals(BigInteger.valueOf( 214L ) ) ); } else { value = value.longValue(); expected = 214L; @@ -1033,9 +634,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[74]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[74] + "' != '" + 138 + "'", - value.equals(BigInteger.valueOf(138L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[74] + "' != '" + 138 + "'", value.equals(BigInteger.valueOf( 138L ) ) ); } else { value = value.longValue(); expected = 138L; @@ -1043,9 +642,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[75]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[75] + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[75] + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -1053,9 +650,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[76]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[76] + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[76] + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -1063,9 +658,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[77]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[77] + "' != '" + 74 + "'", - value.equals(BigInteger.valueOf(74L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[77] + "' != '" + 74 + "'", value.equals(BigInteger.valueOf( 74L ) ) ); } else { value = value.longValue(); expected = 74L; @@ -1073,9 +666,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[78]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[78] + "' != '" + 237 + "'", - value.equals(BigInteger.valueOf(237L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[78] + "' != '" + 237 + "'", value.equals(BigInteger.valueOf( 237L ) ) ); } else { value = value.longValue(); expected = 237L; @@ -1083,9 +674,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[79]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[79] + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[79] + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -1093,9 +682,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[80]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[80] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[80] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -1103,9 +690,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[81]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[81] + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[81] + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -1113,9 +698,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[82]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[82] + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[82] + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -1123,9 +706,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[83]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[83] + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[83] + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -1133,9 +714,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[84]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[84] + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[84] + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -1143,9 +722,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[85]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[85] + "' != '" + 189 + "'", - value.equals(BigInteger.valueOf(189L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[85] + "' != '" + 189 + "'", value.equals(BigInteger.valueOf( 189L ) ) ); } else { value = value.longValue(); expected = 189L; @@ -1153,9 +730,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[86]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[86] + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[86] + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -1163,9 +738,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[87]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[87] + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[87] + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -1173,9 +746,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[88]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[88] + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[88] + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -1183,9 +754,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[89]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[89] + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[89] + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1193,9 +762,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[90]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[90] + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[90] + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1203,9 +770,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[91]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[91] + "' != '" + 159 + "'", - value.equals(BigInteger.valueOf(159L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[91] + "' != '" + 159 + "'", value.equals(BigInteger.valueOf( 159L ) ) ); } else { value = value.longValue(); expected = 159L; @@ -1213,9 +778,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[92]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[92] + "' != '" + 185 + "'", - value.equals(BigInteger.valueOf(185L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[92] + "' != '" + 185 + "'", value.equals(BigInteger.valueOf( 185L ) ) ); } else { value = value.longValue(); expected = 185L; @@ -1223,9 +786,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[93]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[93] + "' != '" + 158 + "'", - value.equals(BigInteger.valueOf(158L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[93] + "' != '" + 158 + "'", value.equals(BigInteger.valueOf( 158L ) ) ); } else { value = value.longValue(); expected = 158L; @@ -1233,9 +794,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[94]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[94] + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[94] + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -1243,9 +802,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[95]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[95] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[95] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1253,9 +810,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[96]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[96] + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[96] + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -1263,9 +818,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[97]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[97] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[97] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -1273,9 +826,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[98]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[98] + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[98] + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -1283,9 +834,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[99]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[99] + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[99] + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -1293,9 +842,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[100]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[100] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[100] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -1303,9 +850,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[101]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[101] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[101] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -1313,9 +858,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[102]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[102] + "' != '" + 85 + "'", - value.equals(BigInteger.valueOf(85L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[102] + "' != '" + 85 + "'", value.equals(BigInteger.valueOf( 85L ) ) ); } else { value = value.longValue(); expected = 85L; @@ -1323,9 +866,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[103]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[103] + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[103] + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -1333,9 +874,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[104]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[104] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[104] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -1343,9 +882,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[105]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[105] + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[105] + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -1353,9 +890,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[106]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[106] + "' != '" + 166 + "'", - value.equals(BigInteger.valueOf(166L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[106] + "' != '" + 166 + "'", value.equals(BigInteger.valueOf( 166L ) ) ); } else { value = value.longValue(); expected = 166L; @@ -1363,9 +898,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[107]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[107] + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[107] + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -1373,9 +906,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[108]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[108] + "' != '" + 139 + "'", - value.equals(BigInteger.valueOf(139L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[108] + "' != '" + 139 + "'", value.equals(BigInteger.valueOf( 139L ) ) ); } else { value = value.longValue(); expected = 139L; @@ -1383,9 +914,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[109]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[109] + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[109] + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -1393,9 +922,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[110]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[110] + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[110] + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -1403,9 +930,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[111]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[111] + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[111] + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -1413,9 +938,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[112]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[112] + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[112] + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -1423,9 +946,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[113]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[113] + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[113] + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -1433,9 +954,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[114]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[114] + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[114] + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -1443,9 +962,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[115]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[115] + "' != '" + 234 + "'", - value.equals(BigInteger.valueOf(234L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[115] + "' != '" + 234 + "'", value.equals(BigInteger.valueOf( 234L ) ) ); } else { value = value.longValue(); expected = 234L; @@ -1453,9 +970,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[116]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[116] + "' != '" + 167 + "'", - value.equals(BigInteger.valueOf(167L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[116] + "' != '" + 167 + "'", value.equals(BigInteger.valueOf( 167L ) ) ); } else { value = value.longValue(); expected = 167L; @@ -1463,9 +978,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[117]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[117] + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[117] + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -1473,9 +986,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[118]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[118] + "' != '" + 247 + "'", - value.equals(BigInteger.valueOf(247L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[118] + "' != '" + 247 + "'", value.equals(BigInteger.valueOf( 247L ) ) ); } else { value = value.longValue(); expected = 247L; @@ -1483,9 +994,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[119]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[119] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[119] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -1493,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[120]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[120] + "' != '" + 239 + "'", - value.equals(BigInteger.valueOf(239L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[120] + "' != '" + 239 + "'", value.equals(BigInteger.valueOf( 239L ) ) ); } else { value = value.longValue(); expected = 239L; @@ -1503,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[121]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[121] + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[121] + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -1513,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[122]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[122] + "' != '" + 188 + "'", - value.equals(BigInteger.valueOf(188L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[122] + "' != '" + 188 + "'", value.equals(BigInteger.valueOf( 188L ) ) ); } else { value = value.longValue(); expected = 188L; @@ -1523,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[123]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[123] + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[123] + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -1533,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[124]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[124] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[124] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -1543,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[125]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[125] + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[125] + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -1553,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[126]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[126] + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[126] + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -1563,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[127]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[127] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[127] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -1573,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[128]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[128] + "' != '" + 251 + "'", - value.equals(BigInteger.valueOf(251L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[128] + "' != '" + 251 + "'", value.equals(BigInteger.valueOf( 251L ) ) ); } else { value = value.longValue(); expected = 251L; @@ -1583,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[129]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[129] + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[129] + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -1593,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[130]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[130] + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[130] + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -1603,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[131]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[131] + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[131] + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -1613,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[132]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[132] + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[132] + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -1623,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[133]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[133] + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[133] + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -1633,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[134]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[134] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[134] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -1643,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[135]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[135] + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[135] + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -1653,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[136]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[136] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[136] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -1663,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[137]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[137] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[137] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -1673,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[138]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[138] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[138] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -1683,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[139]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[139] + "' != '" + 232 + "'", - value.equals(BigInteger.valueOf(232L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[139] + "' != '" + 232 + "'", value.equals(BigInteger.valueOf( 232L ) ) ); } else { value = value.longValue(); expected = 232L; @@ -1693,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[140]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[140] + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[140] + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -1703,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[141]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[141] + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[141] + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -1713,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[142]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[142] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[142] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1723,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[143]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[143] + "' != '" + 90 + "'", - value.equals(BigInteger.valueOf(90L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[143] + "' != '" + 90 + "'", value.equals(BigInteger.valueOf( 90L ) ) ); } else { value = value.longValue(); expected = 90L; @@ -1733,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[144]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[144] + "' != '" + 94 + "'", - value.equals(BigInteger.valueOf(94L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[144] + "' != '" + 94 + "'", value.equals(BigInteger.valueOf( 94L ) ) ); } else { value = value.longValue(); expected = 94L; @@ -1743,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[145]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[145] + "' != '" + 136 + "'", - value.equals(BigInteger.valueOf(136L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[145] + "' != '" + 136 + "'", value.equals(BigInteger.valueOf( 136L ) ) ); } else { value = value.longValue(); expected = 136L; @@ -1753,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[146]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[146] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[146] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1763,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[147]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[147] + "' != '" + 125 + "'", - value.equals(BigInteger.valueOf(125L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[147] + "' != '" + 125 + "'", value.equals(BigInteger.valueOf( 125L ) ) ); } else { value = value.longValue(); expected = 125L; @@ -1773,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[148]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[148] + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[148] + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -1783,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[149]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[149] + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[149] + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -1793,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[150]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[150] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[150] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -1803,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[151]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[151] + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[151] + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -1813,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[152]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[152] + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[152] + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -1823,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[153]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[153] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[153] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -1833,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[154]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[154] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[154] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -1843,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[155]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[155] + "' != '" + 252 + "'", - value.equals(BigInteger.valueOf(252L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[155] + "' != '" + 252 + "'", value.equals(BigInteger.valueOf( 252L ) ) ); } else { value = value.longValue(); expected = 252L; @@ -1853,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[156]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[156] + "' != '" + 229 + "'", - value.equals(BigInteger.valueOf(229L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[156] + "' != '" + 229 + "'", value.equals(BigInteger.valueOf( 229L ) ) ); } else { value = value.longValue(); expected = 229L; @@ -1863,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[157]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[157] + "' != '" + 80 + "'", - value.equals(BigInteger.valueOf(80L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[157] + "' != '" + 80 + "'", value.equals(BigInteger.valueOf( 80L ) ) ); } else { value = value.longValue(); expected = 80L; @@ -1873,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[158]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[158] + "' != '" + 143 + "'", - value.equals(BigInteger.valueOf(143L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[158] + "' != '" + 143 + "'", value.equals(BigInteger.valueOf( 143L ) ) ); } else { value = value.longValue(); expected = 143L; @@ -1883,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[159]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[159] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[159] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -1893,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[160]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[160] + "' != '" + 241 + "'", - value.equals(BigInteger.valueOf(241L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[160] + "' != '" + 241 + "'", value.equals(BigInteger.valueOf( 241L ) ) ); } else { value = value.longValue(); expected = 241L; @@ -1903,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[161]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[161] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[161] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -1913,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[162]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[162] + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[162] + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -1923,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[163]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[163] + "' != '" + 181 + "'", - value.equals(BigInteger.valueOf(181L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[163] + "' != '" + 181 + "'", value.equals(BigInteger.valueOf( 181L ) ) ); } else { value = value.longValue(); expected = 181L; @@ -1933,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[164]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[164] + "' != '" + 155 + "'", - value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[164] + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -1943,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[165]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[165] + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[165] + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -1953,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[166]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[166] + "' != '" + 153 + "'", - value.equals(BigInteger.valueOf(153L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[166] + "' != '" + 153 + "'", value.equals(BigInteger.valueOf( 153L ) ) ); } else { value = value.longValue(); expected = 153L; @@ -1963,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[167]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[167] + "' != '" + 149 + "'", - value.equals(BigInteger.valueOf(149L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[167] + "' != '" + 149 + "'", value.equals(BigInteger.valueOf( 149L ) ) ); } else { value = value.longValue(); expected = 149L; @@ -1973,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[168]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[168] + "' != '" + 152 + "'", - value.equals(BigInteger.valueOf(152L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[168] + "' != '" + 152 + "'", value.equals(BigInteger.valueOf( 152L ) ) ); } else { value = value.longValue(); expected = 152L; @@ -1983,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[169]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[169] + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[169] + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1993,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[170]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[170] + "' != '" + 150 + "'", - value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[170] + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -2003,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[171]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[171] + "' != '" + 87 + "'", - value.equals(BigInteger.valueOf(87L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[171] + "' != '" + 87 + "'", value.equals(BigInteger.valueOf( 87L ) ) ); } else { value = value.longValue(); expected = 87L; @@ -2013,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[172]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[172] + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[172] + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -2023,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[173]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[173] + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[173] + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -2033,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[174]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[174] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[174] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -2043,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[175]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[175] + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[175] + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -2053,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[176]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[176] + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[176] + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -2063,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[177]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[177] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[177] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -2073,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[178]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[178] + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[178] + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -2083,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[179]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[179] + "' != '" + 244 + "'", - value.equals(BigInteger.valueOf(244L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[179] + "' != '" + 244 + "'", value.equals(BigInteger.valueOf( 244L ) ) ); } else { value = value.longValue(); expected = 244L; @@ -2093,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[180]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[180] + "' != '" + 204 + "'", - value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[180] + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -2103,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[181]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[181] + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[181] + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -2113,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[182]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[182] + "' != '" + 253 + "'", - value.equals(BigInteger.valueOf(253L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[182] + "' != '" + 253 + "'", value.equals(BigInteger.valueOf( 253L ) ) ); } else { value = value.longValue(); expected = 253L; @@ -2123,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[183]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[183] + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[183] + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -2133,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[184]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[184] + "' != '" + 122 + "'", - value.equals(BigInteger.valueOf(122L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[184] + "' != '" + 122 + "'", value.equals(BigInteger.valueOf( 122L ) ) ); } else { value = value.longValue(); expected = 122L; @@ -2143,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[185]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[185] + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[185] + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -2153,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[186]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[186] + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[186] + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -2163,9 +1538,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[187]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[187] + "' != '" + 162 + "'", - value.equals(BigInteger.valueOf(162L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[187] + "' != '" + 162 + "'", value.equals(BigInteger.valueOf( 162L ) ) ); } else { value = value.longValue(); expected = 162L; @@ -2173,9 +1546,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[188]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[188] + "' != '" + 197 + "'", - value.equals(BigInteger.valueOf(197L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[188] + "' != '" + 197 + "'", value.equals(BigInteger.valueOf( 197L ) ) ); } else { value = value.longValue(); expected = 197L; @@ -2183,9 +1554,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[189]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[189] + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[189] + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -2193,9 +1562,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[190]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[190] + "' != '" + 199 + "'", - value.equals(BigInteger.valueOf(199L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[190] + "' != '" + 199 + "'", value.equals(BigInteger.valueOf( 199L ) ) ); } else { value = value.longValue(); expected = 199L; @@ -2203,9 +1570,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[191]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[191] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[191] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -2213,9 +1578,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[192]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[192] + "' != '" + 184 + "'", - value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[192] + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -2223,9 +1586,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[193]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[193] + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[193] + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -2233,9 +1594,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[194]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[194] + "' != '" + 206 + "'", - value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[194] + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; @@ -2243,9 +1602,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[195]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[195] + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[195] + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -2253,9 +1610,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[196]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[196] + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[196] + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -2263,9 +1618,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[197]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[197] + "' != '" + 78 + "'", - value.equals(BigInteger.valueOf(78L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[197] + "' != '" + 78 + "'", value.equals(BigInteger.valueOf( 78L ) ) ); } else { value = value.longValue(); expected = 78L; @@ -2273,9 +1626,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[198]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[198] + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[198] + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -2283,9 +1634,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[199]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[199] + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[199] + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -2293,9 +1642,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[200]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[200] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[200] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -2303,9 +1650,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[201]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[201] + "' != '" + 211 + "'", - value.equals(BigInteger.valueOf(211L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[201] + "' != '" + 211 + "'", value.equals(BigInteger.valueOf( 211L ) ) ); } else { value = value.longValue(); expected = 211L; @@ -2313,9 +1658,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[202]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[202] + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[202] + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -2323,9 +1666,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[203]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[203] + "' != '" + 135 + "'", - value.equals(BigInteger.valueOf(135L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[203] + "' != '" + 135 + "'", value.equals(BigInteger.valueOf( 135L ) ) ); } else { value = value.longValue(); expected = 135L; @@ -2333,9 +1674,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[204]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[204] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[204] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -2343,9 +1682,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[205]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[205] + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[205] + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -2353,9 +1690,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[206]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[206] + "' != '" + 79 + "'", - value.equals(BigInteger.valueOf(79L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[206] + "' != '" + 79 + "'", value.equals(BigInteger.valueOf( 79L ) ) ); } else { value = value.longValue(); expected = 79L; @@ -2363,9 +1698,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[207]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[207] + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[207] + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -2373,9 +1706,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[208]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[208] + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[208] + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -2383,9 +1714,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[209]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[209] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[209] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -2393,9 +1722,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[210]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[210] + "' != '" + 161 + "'", - value.equals(BigInteger.valueOf(161L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[210] + "' != '" + 161 + "'", value.equals(BigInteger.valueOf( 161L ) ) ); } else { value = value.longValue(); expected = 161L; @@ -2403,9 +1730,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[211]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[211] + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[211] + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -2413,9 +1738,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[212]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[212] + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[212] + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -2423,9 +1746,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[213]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[213] + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[213] + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -2433,9 +1754,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[214]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[214] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[214] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -2443,9 +1762,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[215]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[215] + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[215] + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -2453,9 +1770,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[216]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[216] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[216] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -2463,9 +1778,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[217]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[217] + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[217] + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -2473,9 +1786,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[218]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[218] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[218] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -2483,9 +1794,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[219]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[219] + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[219] + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -2493,9 +1802,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[220]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[220] + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[220] + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -2503,9 +1810,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[221]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[221] + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[221] + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -2513,9 +1818,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[222]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[222] + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[222] + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -2523,9 +1826,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[223]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[223] + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[223] + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -2533,9 +1834,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[224]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[224] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[224] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2543,9 +1842,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[225]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[225] + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[225] + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -2553,9 +1850,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[226]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[226] + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[226] + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -2563,9 +1858,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[227]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[227] + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[227] + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -2573,9 +1866,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[228]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[228] + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[228] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -2583,9 +1874,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[229]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[229] + "' != '" + 242 + "'", - value.equals(BigInteger.valueOf(242L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[229] + "' != '" + 242 + "'", value.equals(BigInteger.valueOf( 242L ) ) ); } else { value = value.longValue(); expected = 242L; @@ -2593,9 +1882,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[230]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[230] + "' != '" + 110 + "'", - value.equals(BigInteger.valueOf(110L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[230] + "' != '" + 110 + "'", value.equals(BigInteger.valueOf( 110L ) ) ); } else { value = value.longValue(); expected = 110L; @@ -2603,9 +1890,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[231]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[231] + "' != '" + 154 + "'", - value.equals(BigInteger.valueOf(154L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[231] + "' != '" + 154 + "'", value.equals(BigInteger.valueOf( 154L ) ) ); } else { value = value.longValue(); expected = 154L; @@ -2613,9 +1898,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[232]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[232] + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[232] + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -2623,9 +1906,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[233]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[233] + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[233] + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -2633,9 +1914,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[234]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[234] + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[234] + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -2643,9 +1922,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[235]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[235] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[235] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -2653,9 +1930,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[236]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[236] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[236] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -2663,9 +1938,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[237]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[237] + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[237] + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -2673,9 +1946,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[238]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[238] + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[238] + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -2683,9 +1954,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[239]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[239] + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[239] + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -2693,9 +1962,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[240]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[240] + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[240] + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -2703,9 +1970,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[241]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[241] + "' != '" + 209 + "'", - value.equals(BigInteger.valueOf(209L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[241] + "' != '" + 209 + "'", value.equals(BigInteger.valueOf( 209L ) ) ); } else { value = value.longValue(); expected = 209L; @@ -2713,9 +1978,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[242]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[242] + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[242] + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -2723,9 +1986,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[243]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[243] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[243] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -2733,9 +1994,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[244]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[244] + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[244] + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -2743,9 +2002,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[245]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[245] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[245] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -2753,9 +2010,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[246]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[246] + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[246] + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -2763,9 +2018,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[0] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[0] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -2773,9 +2026,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[1] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[1] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -2783,9 +2034,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[2] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[2] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -2793,9 +2042,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[3] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[3] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -2803,8 +2050,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -2812,8 +2058,7 @@ public void test1() throws Throwable { } value = msg.n_msg; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_msg + "' != '" + 48 + "'", value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.n_msg + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; diff --git a/java/test/auto_check_sbp_signing_MsgEcdsaSignatureDepATest.java b/java/test/auto_check_sbp_signing_MsgEcdsaSignatureDepATest.java index b40699185..0f9a79e18 100644 --- a/java/test/auto_check_sbp_signing_MsgEcdsaSignatureDepATest.java +++ b/java/test/auto_check_sbp_signing_MsgEcdsaSignatureDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/signing/test_MsgEcdsaSignatureDepA.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/signing/test_MsgEcdsaSignatureDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.signing.MsgEcdsaSignatureDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_signing_MsgEcdsaSignatureDepATest { @@ -30,274 +34,15 @@ public class auto_check_sbp_signing_MsgEcdsaSignatureDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_signing_MsgEcdsaSignatureDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 10, - (byte) 21, - (byte) 23, - (byte) 63, - (byte) 140, - (byte) 37, - (byte) 130, - (byte) 106, - (byte) 28, - (byte) 40, - (byte) 165, - (byte) 179, - (byte) 73, - (byte) 178, - (byte) 60, - (byte) 126, - (byte) 114, - (byte) 78, - (byte) 113, - (byte) 27, - (byte) 95, - (byte) 3, - (byte) 62, - (byte) 104, - (byte) 145, - (byte) 96, - (byte) 19, - (byte) 92, - (byte) 123, - (byte) 14, - (byte) 90, - (byte) 153, - (byte) 183, - (byte) 9, - (byte) 72, - (byte) 81, - (byte) 118, - (byte) 112, - (byte) 124, - (byte) 16, - (byte) 182, - (byte) 76, - (byte) 146, - (byte) 115, - (byte) 58, - (byte) 144, - (byte) 17, - (byte) 105, - (byte) 66, - (byte) 31, - (byte) 135, - (byte) 54, - (byte) 100, - (byte) 84, - (byte) 181, - (byte) 103, - (byte) 11, - (byte) 88, - (byte) 133, - (byte) 155, - (byte) 167, - (byte) 173, - (byte) 143, - (byte) 86, - (byte) 158, - (byte) 20, - (byte) 168, - (byte) 132, - (byte) 141, - (byte) 102, - (byte) 50, - (byte) 48, - (byte) 71, - (byte) 147, - (byte) 53, - (byte) 87, - (byte) 1, - (byte) 108, - (byte) 138, - (byte) 36, - (byte) 134, - (byte) 139, - (byte) 163, - (byte) 82, - (byte) 43, - (byte) 52, - (byte) 150, - (byte) 12, - (byte) 30, - (byte) 110, - (byte) 156, - (byte) 107, - (byte) 120, - (byte) 91, - (byte) 122, - (byte) 69, - (byte) 164, - (byte) 170, - (byte) 116, - (byte) 25, - (byte) 94, - (byte) 5, - (byte) 22, - (byte) 24, - (byte) 162, - (byte) 175, - (byte) 38, - (byte) 157, - (byte) 98, - (byte) 44, - (byte) 160, - (byte) 47, - (byte) 97, - (byte) 142, - (byte) 8, - (byte) 74, - (byte) 13, - (byte) 177, - (byte) 15, - (byte) 128, - (byte) 26, - (byte) 131, - (byte) 154, - (byte) 65, - (byte) 169, - (byte) 55, - (byte) 136, - (byte) 125, - (byte) 171, - (byte) 161, - (byte) 29, - (byte) 129, - (byte) 151, - (byte) 68, - (byte) 166, - (byte) 51, - (byte) 70, - (byte) 45, - (byte) 56, - (byte) 79, - (byte) 149, - (byte) 99, - (byte) 42, - (byte) 101, - (byte) 152, - (byte) 39, - (byte) 89, - (byte) 180, - (byte) 64, - (byte) 49, - (byte) 6, - (byte) 80, - (byte) 172, - (byte) 32, - (byte) 109, - (byte) 2, - (byte) 119, - (byte) 93, - (byte) 176, - (byte) 0, - (byte) 33, - (byte) 57, - (byte) 34, - (byte) 18, - (byte) 85, - (byte) 121, - (byte) 137, - (byte) 83, - (byte) 111, - (byte) 59, - (byte) 7, - (byte) 77, - (byte) 4, - (byte) 117, - (byte) 159, - (byte) 148, - (byte) 35, - (byte) 61, - (byte) 41, - (byte) 67, - (byte) 46, - (byte) 127, - (byte) 75, - (byte) 174, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xC06, payload); - MsgEcdsaSignatureDepA msg = new MsgEcdsaSignatureDepA(sbp); + byte[] payload = new byte[] {(byte)0,(byte)1,(byte)2,(byte)1,(byte)2,(byte)3,(byte)4,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)10,(byte)21,(byte)23,(byte)63,(byte)140,(byte)37,(byte)130,(byte)106,(byte)28,(byte)40,(byte)165,(byte)179,(byte)73,(byte)178,(byte)60,(byte)126,(byte)114,(byte)78,(byte)113,(byte)27,(byte)95,(byte)3,(byte)62,(byte)104,(byte)145,(byte)96,(byte)19,(byte)92,(byte)123,(byte)14,(byte)90,(byte)153,(byte)183,(byte)9,(byte)72,(byte)81,(byte)118,(byte)112,(byte)124,(byte)16,(byte)182,(byte)76,(byte)146,(byte)115,(byte)58,(byte)144,(byte)17,(byte)105,(byte)66,(byte)31,(byte)135,(byte)54,(byte)100,(byte)84,(byte)181,(byte)103,(byte)11,(byte)88,(byte)133,(byte)155,(byte)167,(byte)173,(byte)143,(byte)86,(byte)158,(byte)20,(byte)168,(byte)132,(byte)141,(byte)102,(byte)50,(byte)48,(byte)71,(byte)147,(byte)53,(byte)87,(byte)1,(byte)108,(byte)138,(byte)36,(byte)134,(byte)139,(byte)163,(byte)82,(byte)43,(byte)52,(byte)150,(byte)12,(byte)30,(byte)110,(byte)156,(byte)107,(byte)120,(byte)91,(byte)122,(byte)69,(byte)164,(byte)170,(byte)116,(byte)25,(byte)94,(byte)5,(byte)22,(byte)24,(byte)162,(byte)175,(byte)38,(byte)157,(byte)98,(byte)44,(byte)160,(byte)47,(byte)97,(byte)142,(byte)8,(byte)74,(byte)13,(byte)177,(byte)15,(byte)128,(byte)26,(byte)131,(byte)154,(byte)65,(byte)169,(byte)55,(byte)136,(byte)125,(byte)171,(byte)161,(byte)29,(byte)129,(byte)151,(byte)68,(byte)166,(byte)51,(byte)70,(byte)45,(byte)56,(byte)79,(byte)149,(byte)99,(byte)42,(byte)101,(byte)152,(byte)39,(byte)89,(byte)180,(byte)64,(byte)49,(byte)6,(byte)80,(byte)172,(byte)32,(byte)109,(byte)2,(byte)119,(byte)93,(byte)176,(byte)0,(byte)33,(byte)57,(byte)34,(byte)18,(byte)85,(byte)121,(byte)137,(byte)83,(byte)111,(byte)59,(byte)7,(byte)77,(byte)4,(byte)117,(byte)159,(byte)148,(byte)35,(byte)61,(byte)41,(byte)67,(byte)46,(byte)127,(byte)75,(byte)174, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xC06, payload ); + MsgEcdsaSignatureDepA msg = new MsgEcdsaSignatureDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.certificate_id[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[0] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[0] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -305,9 +50,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[1] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[1] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -315,9 +58,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[2] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[2] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -325,9 +66,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[3] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[3] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -335,8 +74,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -344,9 +82,7 @@ public void test1() throws Throwable { } value = msg.on_demand_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.on_demand_counter + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.on_demand_counter + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -354,9 +90,7 @@ public void test1() throws Throwable { } value = msg.signature[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -364,9 +98,7 @@ public void test1() throws Throwable { } value = msg.signature[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[1] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[1] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -374,9 +106,7 @@ public void test1() throws Throwable { } value = msg.signature[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[2] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[2] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -384,9 +114,7 @@ public void test1() throws Throwable { } value = msg.signature[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[3] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[3] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -394,9 +122,7 @@ public void test1() throws Throwable { } value = msg.signature[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[4] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[4] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -404,9 +130,7 @@ public void test1() throws Throwable { } value = msg.signature[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[5] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[5] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -414,9 +138,7 @@ public void test1() throws Throwable { } value = msg.signature[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[6] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[6] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -424,9 +146,7 @@ public void test1() throws Throwable { } value = msg.signature[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[7] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[7] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -434,9 +154,7 @@ public void test1() throws Throwable { } value = msg.signature[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[8] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[8] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -444,9 +162,7 @@ public void test1() throws Throwable { } value = msg.signature[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[9] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[9] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -454,9 +170,7 @@ public void test1() throws Throwable { } value = msg.signature[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[10] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[10] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -464,9 +178,7 @@ public void test1() throws Throwable { } value = msg.signature[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[11] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[11] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -474,9 +186,7 @@ public void test1() throws Throwable { } value = msg.signature[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[12] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[12] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -484,9 +194,7 @@ public void test1() throws Throwable { } value = msg.signature[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[13] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[13] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -494,9 +202,7 @@ public void test1() throws Throwable { } value = msg.signature[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[14] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[14] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -504,9 +210,7 @@ public void test1() throws Throwable { } value = msg.signature[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[15] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[15] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -514,9 +218,7 @@ public void test1() throws Throwable { } value = msg.signature[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[16] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[16] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -524,9 +226,7 @@ public void test1() throws Throwable { } value = msg.signature[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[17] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[17] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -534,9 +234,7 @@ public void test1() throws Throwable { } value = msg.signature[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[18] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[18] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -544,9 +242,7 @@ public void test1() throws Throwable { } value = msg.signature[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[19] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[19] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -554,9 +250,7 @@ public void test1() throws Throwable { } value = msg.signature[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[20] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[20] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -564,9 +258,7 @@ public void test1() throws Throwable { } value = msg.signature[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[21] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[21] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -574,9 +266,7 @@ public void test1() throws Throwable { } value = msg.signature[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[22] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[22] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -584,9 +274,7 @@ public void test1() throws Throwable { } value = msg.signature[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[23] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[23] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -594,9 +282,7 @@ public void test1() throws Throwable { } value = msg.signature[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[24] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[24] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -604,9 +290,7 @@ public void test1() throws Throwable { } value = msg.signature[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[25] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[25] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -614,9 +298,7 @@ public void test1() throws Throwable { } value = msg.signature[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[26] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[26] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -624,9 +306,7 @@ public void test1() throws Throwable { } value = msg.signature[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[27] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[27] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -634,9 +314,7 @@ public void test1() throws Throwable { } value = msg.signature[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[28] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[28] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -644,9 +322,7 @@ public void test1() throws Throwable { } value = msg.signature[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[29] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[29] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -654,9 +330,7 @@ public void test1() throws Throwable { } value = msg.signature[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[30] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[30] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -664,9 +338,7 @@ public void test1() throws Throwable { } value = msg.signature[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[31] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[31] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -674,9 +346,7 @@ public void test1() throws Throwable { } value = msg.signature[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[32] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[32] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -684,9 +354,7 @@ public void test1() throws Throwable { } value = msg.signature[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[33] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[33] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -694,9 +362,7 @@ public void test1() throws Throwable { } value = msg.signature[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[34] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[34] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -704,9 +370,7 @@ public void test1() throws Throwable { } value = msg.signature[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[35] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[35] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -714,9 +378,7 @@ public void test1() throws Throwable { } value = msg.signature[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[36] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[36] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -724,9 +386,7 @@ public void test1() throws Throwable { } value = msg.signature[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[37] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[37] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -734,9 +394,7 @@ public void test1() throws Throwable { } value = msg.signature[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[38] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[38] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -744,9 +402,7 @@ public void test1() throws Throwable { } value = msg.signature[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[39] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[39] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -754,9 +410,7 @@ public void test1() throws Throwable { } value = msg.signature[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[40] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[40] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -764,9 +418,7 @@ public void test1() throws Throwable { } value = msg.signature[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[41] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[41] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -774,9 +426,7 @@ public void test1() throws Throwable { } value = msg.signature[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[42] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[42] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -784,9 +434,7 @@ public void test1() throws Throwable { } value = msg.signature[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[43] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[43] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -794,9 +442,7 @@ public void test1() throws Throwable { } value = msg.signature[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[44] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[44] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -804,9 +450,7 @@ public void test1() throws Throwable { } value = msg.signature[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[45] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[45] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -814,9 +458,7 @@ public void test1() throws Throwable { } value = msg.signature[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[46] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[46] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -824,9 +466,7 @@ public void test1() throws Throwable { } value = msg.signature[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[47] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[47] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -834,9 +474,7 @@ public void test1() throws Throwable { } value = msg.signature[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[48] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[48] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -844,9 +482,7 @@ public void test1() throws Throwable { } value = msg.signature[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[49] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[49] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -854,9 +490,7 @@ public void test1() throws Throwable { } value = msg.signature[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[50] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[50] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -864,9 +498,7 @@ public void test1() throws Throwable { } value = msg.signature[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[51] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[51] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -874,9 +506,7 @@ public void test1() throws Throwable { } value = msg.signature[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[52] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[52] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -884,9 +514,7 @@ public void test1() throws Throwable { } value = msg.signature[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[53] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[53] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -894,9 +522,7 @@ public void test1() throws Throwable { } value = msg.signature[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[54] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[54] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -904,9 +530,7 @@ public void test1() throws Throwable { } value = msg.signature[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[55] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[55] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -914,9 +538,7 @@ public void test1() throws Throwable { } value = msg.signature[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[56] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[56] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -924,9 +546,7 @@ public void test1() throws Throwable { } value = msg.signature[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[57] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[57] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -934,9 +554,7 @@ public void test1() throws Throwable { } value = msg.signature[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[58] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[58] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -944,9 +562,7 @@ public void test1() throws Throwable { } value = msg.signature[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[59] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[59] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -954,9 +570,7 @@ public void test1() throws Throwable { } value = msg.signature[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[60] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[60] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -964,9 +578,7 @@ public void test1() throws Throwable { } value = msg.signature[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[61] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[61] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -974,9 +586,7 @@ public void test1() throws Throwable { } value = msg.signature[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[62] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[62] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -984,9 +594,7 @@ public void test1() throws Throwable { } value = msg.signature[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[63] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[63] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -994,9 +602,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[0] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[0] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -1004,9 +610,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[1] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[1] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -1014,9 +618,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[2] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[2] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1024,9 +626,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[3] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[3] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -1034,9 +634,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[4] + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[4] + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -1044,9 +642,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[5] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[5] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -1054,9 +650,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[6] + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[6] + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -1064,9 +658,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[7] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[7] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -1074,9 +666,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[8] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[8] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -1084,9 +674,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[9] + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[9] + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -1094,9 +682,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[10] + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[10] + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -1104,9 +690,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[11] + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[11] + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -1114,9 +698,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[12] + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[12] + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -1124,9 +706,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[13] + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[13] + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -1134,9 +714,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[14] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[14] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -1144,9 +722,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[15] + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[15] + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -1154,9 +730,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[16] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[16] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -1164,9 +738,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[17] + "' != '" + 78 + "'", - value.equals(BigInteger.valueOf(78L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[17] + "' != '" + 78 + "'", value.equals(BigInteger.valueOf( 78L ) ) ); } else { value = value.longValue(); expected = 78L; @@ -1174,9 +746,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[18] + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[18] + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -1184,9 +754,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[19] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[19] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -1194,9 +762,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[20] + "' != '" + 95 + "'", - value.equals(BigInteger.valueOf(95L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[20] + "' != '" + 95 + "'", value.equals(BigInteger.valueOf( 95L ) ) ); } else { value = value.longValue(); expected = 95L; @@ -1204,9 +770,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[21] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[21] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1214,9 +778,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[22] + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[22] + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -1224,9 +786,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[23] + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[23] + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -1234,9 +794,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[24] + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[24] + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -1244,9 +802,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[25] + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[25] + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -1254,9 +810,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[26] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[26] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -1264,9 +818,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[27] + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[27] + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -1274,9 +826,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[28] + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[28] + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -1284,9 +834,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[29] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[29] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -1294,9 +842,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[30] + "' != '" + 90 + "'", - value.equals(BigInteger.valueOf(90L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[30] + "' != '" + 90 + "'", value.equals(BigInteger.valueOf( 90L ) ) ); } else { value = value.longValue(); expected = 90L; @@ -1304,9 +850,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[31] + "' != '" + 153 + "'", - value.equals(BigInteger.valueOf(153L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[31] + "' != '" + 153 + "'", value.equals(BigInteger.valueOf( 153L ) ) ); } else { value = value.longValue(); expected = 153L; @@ -1314,9 +858,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[32] + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[32] + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -1324,9 +866,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[33] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[33] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -1334,9 +874,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[34] + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[34] + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -1344,9 +882,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[35] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[35] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -1354,9 +890,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[36] + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[36] + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -1364,9 +898,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[37] + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[37] + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -1374,9 +906,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[38] + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[38] + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -1384,9 +914,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[39] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[39] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -1394,9 +922,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[40] + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[40] + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -1404,9 +930,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[41] + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[41] + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -1414,9 +938,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[42] + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[42] + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -1424,9 +946,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[43] + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[43] + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1434,9 +954,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[44] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[44] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -1444,9 +962,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[45] + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[45] + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -1454,9 +970,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[46] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[46] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -1464,9 +978,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[47] + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[47] + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -1474,9 +986,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[48] + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[48] + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -1484,9 +994,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[49] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[49] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -1494,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[50] + "' != '" + 135 + "'", - value.equals(BigInteger.valueOf(135L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[50] + "' != '" + 135 + "'", value.equals(BigInteger.valueOf( 135L ) ) ); } else { value = value.longValue(); expected = 135L; @@ -1504,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[51] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[51] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -1514,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[52] + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[52] + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -1524,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[53] + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[53] + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -1534,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[54] + "' != '" + 181 + "'", - value.equals(BigInteger.valueOf(181L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[54] + "' != '" + 181 + "'", value.equals(BigInteger.valueOf( 181L ) ) ); } else { value = value.longValue(); expected = 181L; @@ -1544,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[55] + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[55] + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -1554,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[56] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[56] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -1564,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[57] + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[57] + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -1574,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[58] + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[58] + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -1584,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[59] + "' != '" + 155 + "'", - value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[59] + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -1594,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[60] + "' != '" + 167 + "'", - value.equals(BigInteger.valueOf(167L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[60] + "' != '" + 167 + "'", value.equals(BigInteger.valueOf( 167L ) ) ); } else { value = value.longValue(); expected = 167L; @@ -1604,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[61] + "' != '" + 173 + "'", - value.equals(BigInteger.valueOf(173L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[61] + "' != '" + 173 + "'", value.equals(BigInteger.valueOf( 173L ) ) ); } else { value = value.longValue(); expected = 173L; @@ -1614,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[62] + "' != '" + 143 + "'", - value.equals(BigInteger.valueOf(143L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[62] + "' != '" + 143 + "'", value.equals(BigInteger.valueOf( 143L ) ) ); } else { value = value.longValue(); expected = 143L; @@ -1624,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[63] + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[63] + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -1634,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[64]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[64] + "' != '" + 158 + "'", - value.equals(BigInteger.valueOf(158L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[64] + "' != '" + 158 + "'", value.equals(BigInteger.valueOf( 158L ) ) ); } else { value = value.longValue(); expected = 158L; @@ -1644,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[65]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[65] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[65] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -1654,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[66]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[66] + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[66] + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -1664,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[67]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[67] + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[67] + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -1674,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[68]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[68] + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[68] + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -1684,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[69]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[69] + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[69] + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -1694,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[70]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[70] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[70] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -1704,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[71]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[71] + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[71] + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -1714,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[72]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[72] + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[72] + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -1724,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[73]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[73] + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[73] + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -1734,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[74]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[74] + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[74] + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -1744,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[75]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[75] + "' != '" + 87 + "'", - value.equals(BigInteger.valueOf(87L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[75] + "' != '" + 87 + "'", value.equals(BigInteger.valueOf( 87L ) ) ); } else { value = value.longValue(); expected = 87L; @@ -1754,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[76]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[76] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[76] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1764,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[77]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[77] + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[77] + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -1774,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[78]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[78] + "' != '" + 138 + "'", - value.equals(BigInteger.valueOf(138L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[78] + "' != '" + 138 + "'", value.equals(BigInteger.valueOf( 138L ) ) ); } else { value = value.longValue(); expected = 138L; @@ -1784,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[79]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[79] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[79] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -1794,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[80]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[80] + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[80] + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -1804,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[81]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[81] + "' != '" + 139 + "'", - value.equals(BigInteger.valueOf(139L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[81] + "' != '" + 139 + "'", value.equals(BigInteger.valueOf( 139L ) ) ); } else { value = value.longValue(); expected = 139L; @@ -1814,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[82]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[82] + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[82] + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -1824,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[83]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[83] + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[83] + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -1834,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[84]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[84] + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[84] + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -1844,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[85]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[85] + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[85] + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -1854,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[86]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[86] + "' != '" + 150 + "'", - value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[86] + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -1864,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[87]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[87] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[87] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1874,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[88]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[88] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[88] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -1884,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[89]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[89] + "' != '" + 110 + "'", - value.equals(BigInteger.valueOf(110L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[89] + "' != '" + 110 + "'", value.equals(BigInteger.valueOf( 110L ) ) ); } else { value = value.longValue(); expected = 110L; @@ -1894,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[90]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[90] + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[90] + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -1904,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[91]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[91] + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[91] + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -1914,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[92]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[92] + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[92] + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -1924,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[93]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[93] + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[93] + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -1934,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[94]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[94] + "' != '" + 122 + "'", - value.equals(BigInteger.valueOf(122L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[94] + "' != '" + 122 + "'", value.equals(BigInteger.valueOf( 122L ) ) ); } else { value = value.longValue(); expected = 122L; @@ -1944,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[95]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[95] + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[95] + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -1954,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[96]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[96] + "' != '" + 164 + "'", - value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[96] + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -1964,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[97]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[97] + "' != '" + 170 + "'", - value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[97] + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -1974,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[98]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[98] + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[98] + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1984,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[99]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[99] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[99] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -1994,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[100]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[100] + "' != '" + 94 + "'", - value.equals(BigInteger.valueOf(94L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[100] + "' != '" + 94 + "'", value.equals(BigInteger.valueOf( 94L ) ) ); } else { value = value.longValue(); expected = 94L; @@ -2004,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[101]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[101] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[101] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -2014,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[102]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[102] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[102] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -2024,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[103]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[103] + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[103] + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -2034,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[104]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[104] + "' != '" + 162 + "'", - value.equals(BigInteger.valueOf(162L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[104] + "' != '" + 162 + "'", value.equals(BigInteger.valueOf( 162L ) ) ); } else { value = value.longValue(); expected = 162L; @@ -2044,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[105]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[105] + "' != '" + 175 + "'", - value.equals(BigInteger.valueOf(175L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[105] + "' != '" + 175 + "'", value.equals(BigInteger.valueOf( 175L ) ) ); } else { value = value.longValue(); expected = 175L; @@ -2054,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[106]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[106] + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[106] + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -2064,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[107]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[107] + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[107] + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -2074,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[108]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[108] + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[108] + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -2084,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[109]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[109] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[109] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -2094,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[110]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[110] + "' != '" + 160 + "'", - value.equals(BigInteger.valueOf(160L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[110] + "' != '" + 160 + "'", value.equals(BigInteger.valueOf( 160L ) ) ); } else { value = value.longValue(); expected = 160L; @@ -2104,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[111]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[111] + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[111] + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -2114,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[112]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[112] + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[112] + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -2124,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[113]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[113] + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[113] + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -2134,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[114]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[114] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[114] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -2144,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[115]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[115] + "' != '" + 74 + "'", - value.equals(BigInteger.valueOf(74L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[115] + "' != '" + 74 + "'", value.equals(BigInteger.valueOf( 74L ) ) ); } else { value = value.longValue(); expected = 74L; @@ -2154,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[116]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[116] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[116] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -2164,9 +1538,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[117]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[117] + "' != '" + 177 + "'", - value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[117] + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -2174,9 +1546,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[118]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[118] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[118] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -2184,9 +1554,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[119]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[119] + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[119] + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -2194,9 +1562,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[120]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[120] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[120] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -2204,9 +1570,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[121]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[121] + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[121] + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -2214,9 +1578,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[122]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[122] + "' != '" + 154 + "'", - value.equals(BigInteger.valueOf(154L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[122] + "' != '" + 154 + "'", value.equals(BigInteger.valueOf( 154L ) ) ); } else { value = value.longValue(); expected = 154L; @@ -2224,9 +1586,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[123]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[123] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[123] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -2234,9 +1594,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[124]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[124] + "' != '" + 169 + "'", - value.equals(BigInteger.valueOf(169L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[124] + "' != '" + 169 + "'", value.equals(BigInteger.valueOf( 169L ) ) ); } else { value = value.longValue(); expected = 169L; @@ -2244,9 +1602,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[125]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[125] + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[125] + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -2254,9 +1610,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[126]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[126] + "' != '" + 136 + "'", - value.equals(BigInteger.valueOf(136L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[126] + "' != '" + 136 + "'", value.equals(BigInteger.valueOf( 136L ) ) ); } else { value = value.longValue(); expected = 136L; @@ -2264,9 +1618,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[127]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[127] + "' != '" + 125 + "'", - value.equals(BigInteger.valueOf(125L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[127] + "' != '" + 125 + "'", value.equals(BigInteger.valueOf( 125L ) ) ); } else { value = value.longValue(); expected = 125L; @@ -2274,9 +1626,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[128]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[128] + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[128] + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -2284,9 +1634,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[129]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[129] + "' != '" + 161 + "'", - value.equals(BigInteger.valueOf(161L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[129] + "' != '" + 161 + "'", value.equals(BigInteger.valueOf( 161L ) ) ); } else { value = value.longValue(); expected = 161L; @@ -2294,9 +1642,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[130]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[130] + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[130] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -2304,9 +1650,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[131]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[131] + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[131] + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -2314,9 +1658,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[132]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[132] + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[132] + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -2324,9 +1666,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[133]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[133] + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[133] + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -2334,9 +1674,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[134]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[134] + "' != '" + 166 + "'", - value.equals(BigInteger.valueOf(166L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[134] + "' != '" + 166 + "'", value.equals(BigInteger.valueOf( 166L ) ) ); } else { value = value.longValue(); expected = 166L; @@ -2344,9 +1682,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[135]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[135] + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[135] + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -2354,9 +1690,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[136]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[136] + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[136] + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -2364,9 +1698,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[137]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[137] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[137] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -2374,9 +1706,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[138]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[138] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[138] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -2384,9 +1714,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[139]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[139] + "' != '" + 79 + "'", - value.equals(BigInteger.valueOf(79L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[139] + "' != '" + 79 + "'", value.equals(BigInteger.valueOf( 79L ) ) ); } else { value = value.longValue(); expected = 79L; @@ -2394,9 +1722,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[140]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[140] + "' != '" + 149 + "'", - value.equals(BigInteger.valueOf(149L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[140] + "' != '" + 149 + "'", value.equals(BigInteger.valueOf( 149L ) ) ); } else { value = value.longValue(); expected = 149L; @@ -2404,9 +1730,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[141]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[141] + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[141] + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -2414,9 +1738,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[142]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[142] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[142] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -2424,9 +1746,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[143]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[143] + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[143] + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -2434,9 +1754,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[144]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[144] + "' != '" + 152 + "'", - value.equals(BigInteger.valueOf(152L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[144] + "' != '" + 152 + "'", value.equals(BigInteger.valueOf( 152L ) ) ); } else { value = value.longValue(); expected = 152L; @@ -2444,9 +1762,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[145]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[145] + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[145] + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -2454,9 +1770,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[146]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[146] + "' != '" + 89 + "'", - value.equals(BigInteger.valueOf(89L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[146] + "' != '" + 89 + "'", value.equals(BigInteger.valueOf( 89L ) ) ); } else { value = value.longValue(); expected = 89L; @@ -2464,9 +1778,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[147]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[147] + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[147] + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -2474,9 +1786,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[148]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[148] + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[148] + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -2484,9 +1794,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[149]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[149] + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[149] + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -2494,9 +1802,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[150]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[150] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[150] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -2504,9 +1810,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[151]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[151] + "' != '" + 80 + "'", - value.equals(BigInteger.valueOf(80L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[151] + "' != '" + 80 + "'", value.equals(BigInteger.valueOf( 80L ) ) ); } else { value = value.longValue(); expected = 80L; @@ -2514,9 +1818,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[152]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[152] + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[152] + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -2524,9 +1826,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[153]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[153] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[153] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -2534,9 +1834,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[154]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[154] + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[154] + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -2544,9 +1842,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[155]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[155] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[155] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -2554,9 +1850,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[156]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[156] + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[156] + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -2564,9 +1858,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[157]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[157] + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[157] + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -2574,9 +1866,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[158]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[158] + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[158] + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -2584,9 +1874,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[159]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[159] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[159] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2594,9 +1882,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[160]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[160] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[160] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -2604,9 +1890,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[161]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[161] + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[161] + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -2614,9 +1898,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[162]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[162] + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[162] + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -2624,9 +1906,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[163]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[163] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[163] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -2634,9 +1914,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[164]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[164] + "' != '" + 85 + "'", - value.equals(BigInteger.valueOf(85L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[164] + "' != '" + 85 + "'", value.equals(BigInteger.valueOf( 85L ) ) ); } else { value = value.longValue(); expected = 85L; @@ -2644,9 +1922,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[165]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[165] + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[165] + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -2654,9 +1930,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[166]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[166] + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[166] + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -2664,9 +1938,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[167]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[167] + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[167] + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -2674,9 +1946,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[168]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[168] + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[168] + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -2684,9 +1954,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[169]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[169] + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[169] + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -2694,9 +1962,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[170]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[170] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[170] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -2704,9 +1970,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[171]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[171] + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[171] + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -2714,9 +1978,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[172]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[172] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[172] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -2724,9 +1986,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[173]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[173] + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[173] + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -2734,9 +1994,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[174]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[174] + "' != '" + 159 + "'", - value.equals(BigInteger.valueOf(159L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[174] + "' != '" + 159 + "'", value.equals(BigInteger.valueOf( 159L ) ) ); } else { value = value.longValue(); expected = 159L; @@ -2744,9 +2002,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[175]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[175] + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[175] + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -2754,9 +2010,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[176]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[176] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[176] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -2764,9 +2018,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[177]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[177] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[177] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -2774,9 +2026,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[178]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[178] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[178] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -2784,9 +2034,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[179]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[179] + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[179] + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -2794,9 +2042,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[180]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[180] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[180] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -2804,9 +2050,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[181]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[181] + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[181] + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -2814,9 +2058,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[182]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[182] + "' != '" + 75 + "'", - value.equals(BigInteger.valueOf(75L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[182] + "' != '" + 75 + "'", value.equals(BigInteger.valueOf( 75L ) ) ); } else { value = value.longValue(); expected = 75L; @@ -2824,9 +2066,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[183]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[183] + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[183] + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -2834,9 +2074,7 @@ public void test1() throws Throwable { } value = msg.stream_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stream_counter + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.stream_counter + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; diff --git a/java/test/auto_check_sbp_signing_MsgEcdsaSignatureDepBTest.java b/java/test/auto_check_sbp_signing_MsgEcdsaSignatureDepBTest.java index fe9be3c3b..7f03a7977 100644 --- a/java/test/auto_check_sbp_signing_MsgEcdsaSignatureDepBTest.java +++ b/java/test/auto_check_sbp_signing_MsgEcdsaSignatureDepBTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/signing/test_MsgEcdsaSignatureDepB.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/signing/test_MsgEcdsaSignatureDepB.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.signing.MsgEcdsaSignatureDepB; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_signing_MsgEcdsaSignatureDepBTest { @@ -30,31 +34,15 @@ public class auto_check_sbp_signing_MsgEcdsaSignatureDepBTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_signing_MsgEcdsaSignatureDepBTest.test1"); - byte[] payload = - new byte[] { - (byte) 0, (byte) 1, (byte) 2, (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 72, - (byte) 0, (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5, (byte) 6, (byte) 7, - (byte) 8, (byte) 9, (byte) 10, (byte) 11, (byte) 12, (byte) 13, (byte) 14, - (byte) 15, (byte) 16, (byte) 17, (byte) 18, (byte) 19, (byte) 20, (byte) 21, - (byte) 22, (byte) 23, (byte) 24, (byte) 25, (byte) 26, (byte) 27, (byte) 28, - (byte) 29, (byte) 30, (byte) 31, (byte) 32, (byte) 33, (byte) 34, (byte) 35, - (byte) 36, (byte) 37, (byte) 38, (byte) 39, (byte) 40, (byte) 41, (byte) 42, - (byte) 43, (byte) 44, (byte) 45, (byte) 46, (byte) 47, (byte) 48, (byte) 49, - (byte) 50, (byte) 51, (byte) 52, (byte) 53, (byte) 54, (byte) 55, (byte) 56, - (byte) 57, (byte) 58, (byte) 59, (byte) 60, (byte) 61, (byte) 62, (byte) 63, - (byte) 64, (byte) 65, (byte) 66, (byte) 67, (byte) 68, (byte) 69, (byte) 70, - (byte) 71, (byte) 10, (byte) 21, (byte) 23, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xC07, payload); - MsgEcdsaSignatureDepB msg = new MsgEcdsaSignatureDepB(sbp); + byte[] payload = new byte[] {(byte)0,(byte)1,(byte)2,(byte)1,(byte)2,(byte)3,(byte)4,(byte)72,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)8,(byte)9,(byte)10,(byte)11,(byte)12,(byte)13,(byte)14,(byte)15,(byte)16,(byte)17,(byte)18,(byte)19,(byte)20,(byte)21,(byte)22,(byte)23,(byte)24,(byte)25,(byte)26,(byte)27,(byte)28,(byte)29,(byte)30,(byte)31,(byte)32,(byte)33,(byte)34,(byte)35,(byte)36,(byte)37,(byte)38,(byte)39,(byte)40,(byte)41,(byte)42,(byte)43,(byte)44,(byte)45,(byte)46,(byte)47,(byte)48,(byte)49,(byte)50,(byte)51,(byte)52,(byte)53,(byte)54,(byte)55,(byte)56,(byte)57,(byte)58,(byte)59,(byte)60,(byte)61,(byte)62,(byte)63,(byte)64,(byte)65,(byte)66,(byte)67,(byte)68,(byte)69,(byte)70,(byte)71,(byte)10,(byte)21,(byte)23, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xC07, payload ); + MsgEcdsaSignatureDepB msg = new MsgEcdsaSignatureDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.certificate_id[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[0] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[0] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -62,9 +50,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[1] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[1] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -72,9 +58,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[2] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[2] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -82,9 +66,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[3] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[3] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -92,8 +74,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -101,9 +82,7 @@ public void test1() throws Throwable { } value = msg.n_signature_bytes; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_signature_bytes + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.n_signature_bytes + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -111,9 +90,7 @@ public void test1() throws Throwable { } value = msg.on_demand_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.on_demand_counter + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.on_demand_counter + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -121,9 +98,7 @@ public void test1() throws Throwable { } value = msg.signature[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -131,9 +106,7 @@ public void test1() throws Throwable { } value = msg.signature[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[1] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[1] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -141,9 +114,7 @@ public void test1() throws Throwable { } value = msg.signature[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[2] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[2] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -151,9 +122,7 @@ public void test1() throws Throwable { } value = msg.signature[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[3] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[3] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -161,9 +130,7 @@ public void test1() throws Throwable { } value = msg.signature[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[4] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[4] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -171,9 +138,7 @@ public void test1() throws Throwable { } value = msg.signature[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[5] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[5] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -181,9 +146,7 @@ public void test1() throws Throwable { } value = msg.signature[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[6] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[6] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -191,9 +154,7 @@ public void test1() throws Throwable { } value = msg.signature[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[7] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[7] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -201,9 +162,7 @@ public void test1() throws Throwable { } value = msg.signature[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[8] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.signature[8] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -211,9 +170,7 @@ public void test1() throws Throwable { } value = msg.signature[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[9] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.signature[9] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -221,9 +178,7 @@ public void test1() throws Throwable { } value = msg.signature[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[10] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.signature[10] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -231,9 +186,7 @@ public void test1() throws Throwable { } value = msg.signature[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[11] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.signature[11] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -241,9 +194,7 @@ public void test1() throws Throwable { } value = msg.signature[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[12] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.signature[12] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -251,9 +202,7 @@ public void test1() throws Throwable { } value = msg.signature[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[13] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.signature[13] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -261,9 +210,7 @@ public void test1() throws Throwable { } value = msg.signature[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[14] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.signature[14] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -271,9 +218,7 @@ public void test1() throws Throwable { } value = msg.signature[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[15] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.signature[15] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -281,9 +226,7 @@ public void test1() throws Throwable { } value = msg.signature[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[16] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.signature[16] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -291,9 +234,7 @@ public void test1() throws Throwable { } value = msg.signature[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[17] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.signature[17] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -301,9 +242,7 @@ public void test1() throws Throwable { } value = msg.signature[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[18] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.signature[18] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -311,9 +250,7 @@ public void test1() throws Throwable { } value = msg.signature[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[19] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.signature[19] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -321,9 +258,7 @@ public void test1() throws Throwable { } value = msg.signature[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[20] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.signature[20] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -331,9 +266,7 @@ public void test1() throws Throwable { } value = msg.signature[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[21] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.signature[21] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -341,9 +274,7 @@ public void test1() throws Throwable { } value = msg.signature[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[22] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.signature[22] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -351,9 +282,7 @@ public void test1() throws Throwable { } value = msg.signature[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[23] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.signature[23] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -361,9 +290,7 @@ public void test1() throws Throwable { } value = msg.signature[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[24] + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.signature[24] + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -371,9 +298,7 @@ public void test1() throws Throwable { } value = msg.signature[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[25] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.signature[25] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -381,9 +306,7 @@ public void test1() throws Throwable { } value = msg.signature[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[26] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.signature[26] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -391,9 +314,7 @@ public void test1() throws Throwable { } value = msg.signature[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[27] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.signature[27] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -401,9 +322,7 @@ public void test1() throws Throwable { } value = msg.signature[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[28] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.signature[28] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -411,9 +330,7 @@ public void test1() throws Throwable { } value = msg.signature[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[29] + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.signature[29] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -421,9 +338,7 @@ public void test1() throws Throwable { } value = msg.signature[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[30] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.signature[30] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -431,9 +346,7 @@ public void test1() throws Throwable { } value = msg.signature[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[31] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.signature[31] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -441,9 +354,7 @@ public void test1() throws Throwable { } value = msg.signature[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[32] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.signature[32] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -451,9 +362,7 @@ public void test1() throws Throwable { } value = msg.signature[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[33] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.signature[33] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -461,9 +370,7 @@ public void test1() throws Throwable { } value = msg.signature[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[34] + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.signature[34] + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -471,9 +378,7 @@ public void test1() throws Throwable { } value = msg.signature[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[35] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.signature[35] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -481,9 +386,7 @@ public void test1() throws Throwable { } value = msg.signature[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[36] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.signature[36] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -491,9 +394,7 @@ public void test1() throws Throwable { } value = msg.signature[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[37] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.signature[37] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -501,9 +402,7 @@ public void test1() throws Throwable { } value = msg.signature[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[38] + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.signature[38] + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -511,9 +410,7 @@ public void test1() throws Throwable { } value = msg.signature[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[39] + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.signature[39] + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -521,9 +418,7 @@ public void test1() throws Throwable { } value = msg.signature[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[40] + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.signature[40] + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -531,9 +426,7 @@ public void test1() throws Throwable { } value = msg.signature[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[41] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.signature[41] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -541,9 +434,7 @@ public void test1() throws Throwable { } value = msg.signature[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[42] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.signature[42] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -551,9 +442,7 @@ public void test1() throws Throwable { } value = msg.signature[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[43] + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.signature[43] + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -561,9 +450,7 @@ public void test1() throws Throwable { } value = msg.signature[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[44] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.signature[44] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -571,9 +458,7 @@ public void test1() throws Throwable { } value = msg.signature[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[45] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.signature[45] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -581,9 +466,7 @@ public void test1() throws Throwable { } value = msg.signature[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[46] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.signature[46] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -591,9 +474,7 @@ public void test1() throws Throwable { } value = msg.signature[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[47] + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.signature[47] + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -601,9 +482,7 @@ public void test1() throws Throwable { } value = msg.signature[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[48] + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.signature[48] + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -611,9 +490,7 @@ public void test1() throws Throwable { } value = msg.signature[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[49] + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.signature[49] + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -621,9 +498,7 @@ public void test1() throws Throwable { } value = msg.signature[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[50] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.signature[50] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -631,9 +506,7 @@ public void test1() throws Throwable { } value = msg.signature[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[51] + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.signature[51] + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -641,9 +514,7 @@ public void test1() throws Throwable { } value = msg.signature[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[52] + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.signature[52] + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -651,9 +522,7 @@ public void test1() throws Throwable { } value = msg.signature[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[53] + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.signature[53] + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -661,9 +530,7 @@ public void test1() throws Throwable { } value = msg.signature[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[54] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.signature[54] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -671,9 +538,7 @@ public void test1() throws Throwable { } value = msg.signature[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[55] + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.signature[55] + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -681,9 +546,7 @@ public void test1() throws Throwable { } value = msg.signature[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[56] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.signature[56] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -691,9 +554,7 @@ public void test1() throws Throwable { } value = msg.signature[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[57] + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.signature[57] + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -701,9 +562,7 @@ public void test1() throws Throwable { } value = msg.signature[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[58] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.signature[58] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -711,9 +570,7 @@ public void test1() throws Throwable { } value = msg.signature[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[59] + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.signature[59] + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -721,9 +578,7 @@ public void test1() throws Throwable { } value = msg.signature[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[60] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.signature[60] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -731,9 +586,7 @@ public void test1() throws Throwable { } value = msg.signature[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[61] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.signature[61] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -741,9 +594,7 @@ public void test1() throws Throwable { } value = msg.signature[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[62] + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.signature[62] + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -751,9 +602,7 @@ public void test1() throws Throwable { } value = msg.signature[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[63] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.signature[63] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -761,9 +610,7 @@ public void test1() throws Throwable { } value = msg.signature[64]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[64] + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.signature[64] + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -771,9 +618,7 @@ public void test1() throws Throwable { } value = msg.signature[65]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[65] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.signature[65] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -781,9 +626,7 @@ public void test1() throws Throwable { } value = msg.signature[66]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[66] + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.signature[66] + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -791,9 +634,7 @@ public void test1() throws Throwable { } value = msg.signature[67]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[67] + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.signature[67] + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -801,9 +642,7 @@ public void test1() throws Throwable { } value = msg.signature[68]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[68] + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.signature[68] + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -811,9 +650,7 @@ public void test1() throws Throwable { } value = msg.signature[69]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[69] + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.signature[69] + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -821,9 +658,7 @@ public void test1() throws Throwable { } value = msg.signature[70]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[70] + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.signature[70] + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -831,9 +666,7 @@ public void test1() throws Throwable { } value = msg.signature[71]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[71] + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.signature[71] + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -841,9 +674,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[0] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[0] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -851,9 +682,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[1] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[1] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -861,9 +690,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[2] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[2] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -871,9 +698,7 @@ public void test1() throws Throwable { } value = msg.stream_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stream_counter + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.stream_counter + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; diff --git a/java/test/auto_check_sbp_signing_MsgEcdsaSignatureTest.java b/java/test/auto_check_sbp_signing_MsgEcdsaSignatureTest.java index dd68ed390..5ee07ce12 100644 --- a/java/test/auto_check_sbp_signing_MsgEcdsaSignatureTest.java +++ b/java/test/auto_check_sbp_signing_MsgEcdsaSignatureTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/signing/test_MsgEcdsaSignature.yaml by generate.py. Do not modify by -// hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/signing/test_MsgEcdsaSignature.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.signing.MsgEcdsaSignature; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_signing_MsgEcdsaSignatureTest { @@ -30,31 +34,15 @@ public class auto_check_sbp_signing_MsgEcdsaSignatureTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_signing_MsgEcdsaSignatureTest.test1"); - byte[] payload = - new byte[] { - (byte) 0, (byte) 1, (byte) 2, (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 72, - (byte) 0, (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5, (byte) 6, (byte) 7, - (byte) 8, (byte) 9, (byte) 10, (byte) 11, (byte) 12, (byte) 13, (byte) 14, - (byte) 15, (byte) 16, (byte) 17, (byte) 18, (byte) 19, (byte) 20, (byte) 21, - (byte) 22, (byte) 23, (byte) 24, (byte) 25, (byte) 26, (byte) 27, (byte) 28, - (byte) 29, (byte) 30, (byte) 31, (byte) 32, (byte) 33, (byte) 34, (byte) 35, - (byte) 36, (byte) 37, (byte) 38, (byte) 39, (byte) 40, (byte) 41, (byte) 42, - (byte) 43, (byte) 44, (byte) 45, (byte) 46, (byte) 47, (byte) 48, (byte) 49, - (byte) 50, (byte) 51, (byte) 52, (byte) 53, (byte) 54, (byte) 55, (byte) 56, - (byte) 57, (byte) 58, (byte) 59, (byte) 60, (byte) 61, (byte) 62, (byte) 63, - (byte) 64, (byte) 65, (byte) 66, (byte) 67, (byte) 68, (byte) 69, (byte) 70, - (byte) 71, (byte) 10, (byte) 21, (byte) 23, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xC08, payload); - MsgEcdsaSignature msg = new MsgEcdsaSignature(sbp); + byte[] payload = new byte[] {(byte)0,(byte)1,(byte)2,(byte)1,(byte)2,(byte)3,(byte)4,(byte)72,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)8,(byte)9,(byte)10,(byte)11,(byte)12,(byte)13,(byte)14,(byte)15,(byte)16,(byte)17,(byte)18,(byte)19,(byte)20,(byte)21,(byte)22,(byte)23,(byte)24,(byte)25,(byte)26,(byte)27,(byte)28,(byte)29,(byte)30,(byte)31,(byte)32,(byte)33,(byte)34,(byte)35,(byte)36,(byte)37,(byte)38,(byte)39,(byte)40,(byte)41,(byte)42,(byte)43,(byte)44,(byte)45,(byte)46,(byte)47,(byte)48,(byte)49,(byte)50,(byte)51,(byte)52,(byte)53,(byte)54,(byte)55,(byte)56,(byte)57,(byte)58,(byte)59,(byte)60,(byte)61,(byte)62,(byte)63,(byte)64,(byte)65,(byte)66,(byte)67,(byte)68,(byte)69,(byte)70,(byte)71,(byte)10,(byte)21,(byte)23, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xC08, payload ); + MsgEcdsaSignature msg = new MsgEcdsaSignature( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.certificate_id[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[0] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[0] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -62,9 +50,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[1] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[1] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -72,9 +58,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[2] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[2] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -82,9 +66,7 @@ public void test1() throws Throwable { } value = msg.certificate_id[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_id[3] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.certificate_id[3] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -92,8 +74,7 @@ public void test1() throws Throwable { } value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -101,9 +82,7 @@ public void test1() throws Throwable { } value = msg.on_demand_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.on_demand_counter + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.on_demand_counter + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -111,9 +90,7 @@ public void test1() throws Throwable { } value = msg.signature.data[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -121,9 +98,7 @@ public void test1() throws Throwable { } value = msg.signature.data[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[1] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[1] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -131,9 +106,7 @@ public void test1() throws Throwable { } value = msg.signature.data[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[2] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[2] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -141,9 +114,7 @@ public void test1() throws Throwable { } value = msg.signature.data[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[3] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[3] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -151,9 +122,7 @@ public void test1() throws Throwable { } value = msg.signature.data[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[4] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[4] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -161,9 +130,7 @@ public void test1() throws Throwable { } value = msg.signature.data[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[5] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[5] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -171,9 +138,7 @@ public void test1() throws Throwable { } value = msg.signature.data[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[6] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[6] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -181,9 +146,7 @@ public void test1() throws Throwable { } value = msg.signature.data[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[7] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[7] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -191,9 +154,7 @@ public void test1() throws Throwable { } value = msg.signature.data[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[8] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[8] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -201,9 +162,7 @@ public void test1() throws Throwable { } value = msg.signature.data[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[9] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[9] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -211,9 +170,7 @@ public void test1() throws Throwable { } value = msg.signature.data[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[10] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[10] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -221,9 +178,7 @@ public void test1() throws Throwable { } value = msg.signature.data[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[11] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[11] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -231,9 +186,7 @@ public void test1() throws Throwable { } value = msg.signature.data[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[12] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[12] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -241,9 +194,7 @@ public void test1() throws Throwable { } value = msg.signature.data[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[13] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[13] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -251,9 +202,7 @@ public void test1() throws Throwable { } value = msg.signature.data[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[14] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[14] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -261,9 +210,7 @@ public void test1() throws Throwable { } value = msg.signature.data[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[15] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[15] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -271,9 +218,7 @@ public void test1() throws Throwable { } value = msg.signature.data[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[16] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[16] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -281,9 +226,7 @@ public void test1() throws Throwable { } value = msg.signature.data[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[17] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[17] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -291,9 +234,7 @@ public void test1() throws Throwable { } value = msg.signature.data[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[18] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[18] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -301,9 +242,7 @@ public void test1() throws Throwable { } value = msg.signature.data[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[19] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[19] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -311,9 +250,7 @@ public void test1() throws Throwable { } value = msg.signature.data[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[20] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[20] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -321,9 +258,7 @@ public void test1() throws Throwable { } value = msg.signature.data[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[21] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[21] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -331,9 +266,7 @@ public void test1() throws Throwable { } value = msg.signature.data[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[22] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[22] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -341,9 +274,7 @@ public void test1() throws Throwable { } value = msg.signature.data[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[23] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[23] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -351,9 +282,7 @@ public void test1() throws Throwable { } value = msg.signature.data[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[24] + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[24] + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -361,9 +290,7 @@ public void test1() throws Throwable { } value = msg.signature.data[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[25] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[25] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -371,9 +298,7 @@ public void test1() throws Throwable { } value = msg.signature.data[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[26] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[26] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -381,9 +306,7 @@ public void test1() throws Throwable { } value = msg.signature.data[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[27] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[27] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -391,9 +314,7 @@ public void test1() throws Throwable { } value = msg.signature.data[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[28] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[28] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -401,9 +322,7 @@ public void test1() throws Throwable { } value = msg.signature.data[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[29] + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[29] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -411,9 +330,7 @@ public void test1() throws Throwable { } value = msg.signature.data[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[30] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[30] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -421,9 +338,7 @@ public void test1() throws Throwable { } value = msg.signature.data[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[31] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[31] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -431,9 +346,7 @@ public void test1() throws Throwable { } value = msg.signature.data[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[32] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[32] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -441,9 +354,7 @@ public void test1() throws Throwable { } value = msg.signature.data[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[33] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[33] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -451,9 +362,7 @@ public void test1() throws Throwable { } value = msg.signature.data[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[34] + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[34] + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -461,9 +370,7 @@ public void test1() throws Throwable { } value = msg.signature.data[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[35] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[35] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -471,9 +378,7 @@ public void test1() throws Throwable { } value = msg.signature.data[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[36] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[36] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -481,9 +386,7 @@ public void test1() throws Throwable { } value = msg.signature.data[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[37] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[37] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -491,9 +394,7 @@ public void test1() throws Throwable { } value = msg.signature.data[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[38] + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[38] + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -501,9 +402,7 @@ public void test1() throws Throwable { } value = msg.signature.data[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[39] + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[39] + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -511,9 +410,7 @@ public void test1() throws Throwable { } value = msg.signature.data[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[40] + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[40] + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -521,9 +418,7 @@ public void test1() throws Throwable { } value = msg.signature.data[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[41] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[41] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -531,9 +426,7 @@ public void test1() throws Throwable { } value = msg.signature.data[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[42] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[42] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -541,9 +434,7 @@ public void test1() throws Throwable { } value = msg.signature.data[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[43] + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[43] + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -551,9 +442,7 @@ public void test1() throws Throwable { } value = msg.signature.data[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[44] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[44] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -561,9 +450,7 @@ public void test1() throws Throwable { } value = msg.signature.data[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[45] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[45] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -571,9 +458,7 @@ public void test1() throws Throwable { } value = msg.signature.data[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[46] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[46] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -581,9 +466,7 @@ public void test1() throws Throwable { } value = msg.signature.data[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[47] + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[47] + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -591,9 +474,7 @@ public void test1() throws Throwable { } value = msg.signature.data[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[48] + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[48] + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -601,9 +482,7 @@ public void test1() throws Throwable { } value = msg.signature.data[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[49] + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[49] + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -611,9 +490,7 @@ public void test1() throws Throwable { } value = msg.signature.data[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[50] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[50] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -621,9 +498,7 @@ public void test1() throws Throwable { } value = msg.signature.data[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[51] + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[51] + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -631,9 +506,7 @@ public void test1() throws Throwable { } value = msg.signature.data[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[52] + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[52] + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -641,9 +514,7 @@ public void test1() throws Throwable { } value = msg.signature.data[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[53] + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[53] + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -651,9 +522,7 @@ public void test1() throws Throwable { } value = msg.signature.data[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[54] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[54] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -661,9 +530,7 @@ public void test1() throws Throwable { } value = msg.signature.data[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[55] + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[55] + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -671,9 +538,7 @@ public void test1() throws Throwable { } value = msg.signature.data[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[56] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[56] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -681,9 +546,7 @@ public void test1() throws Throwable { } value = msg.signature.data[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[57] + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[57] + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -691,9 +554,7 @@ public void test1() throws Throwable { } value = msg.signature.data[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[58] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[58] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -701,9 +562,7 @@ public void test1() throws Throwable { } value = msg.signature.data[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[59] + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[59] + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -711,9 +570,7 @@ public void test1() throws Throwable { } value = msg.signature.data[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[60] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[60] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -721,9 +578,7 @@ public void test1() throws Throwable { } value = msg.signature.data[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[61] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[61] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -731,9 +586,7 @@ public void test1() throws Throwable { } value = msg.signature.data[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[62] + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[62] + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -741,9 +594,7 @@ public void test1() throws Throwable { } value = msg.signature.data[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[63] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[63] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -751,9 +602,7 @@ public void test1() throws Throwable { } value = msg.signature.data[64]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[64] + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[64] + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -761,9 +610,7 @@ public void test1() throws Throwable { } value = msg.signature.data[65]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[65] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[65] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -771,9 +618,7 @@ public void test1() throws Throwable { } value = msg.signature.data[66]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[66] + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[66] + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -781,9 +626,7 @@ public void test1() throws Throwable { } value = msg.signature.data[67]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[67] + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[67] + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -791,9 +634,7 @@ public void test1() throws Throwable { } value = msg.signature.data[68]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[68] + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[68] + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -801,9 +642,7 @@ public void test1() throws Throwable { } value = msg.signature.data[69]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[69] + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[69] + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -811,9 +650,7 @@ public void test1() throws Throwable { } value = msg.signature.data[70]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[70] + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[70] + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -821,9 +658,7 @@ public void test1() throws Throwable { } value = msg.signature.data[71]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.data[71] + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.signature.data[71] + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -831,9 +666,7 @@ public void test1() throws Throwable { } value = msg.signature.len; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature.len + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.signature.len + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -841,9 +674,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[0] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[0] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -851,9 +682,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[1] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[1] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -861,9 +690,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[2] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[2] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -871,9 +698,7 @@ public void test1() throws Throwable { } value = msg.stream_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stream_counter + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.stream_counter + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; diff --git a/java/test/auto_check_sbp_signing_MsgEd25519CertificateDepTest.java b/java/test/auto_check_sbp_signing_MsgEd25519CertificateDepTest.java index 1296911d3..89bb72ab9 100644 --- a/java/test/auto_check_sbp_signing_MsgEd25519CertificateDepTest.java +++ b/java/test/auto_check_sbp_signing_MsgEd25519CertificateDepTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/signing/test_MsgEd25519CertificateDep.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/signing/test_MsgEd25519CertificateDep.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.signing.MsgEd25519CertificateDep; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_signing_MsgEd25519CertificateDepTest { @@ -29,127 +33,16 @@ public class auto_check_sbp_signing_MsgEd25519CertificateDepTest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_signing_MsgEd25519CertificateDepTest.test1"); - byte[] payload = - new byte[] { - (byte) 16, - (byte) 100, - (byte) 101, - (byte) 102, - (byte) 103, - (byte) 104, - (byte) 105, - (byte) 106, - (byte) 107, - (byte) 108, - (byte) 109, - (byte) 110, - (byte) 111, - (byte) 112, - (byte) 113, - (byte) 114, - (byte) 115, - (byte) 116, - (byte) 117, - (byte) 118, - (byte) 119, - (byte) 0, - (byte) 3, - (byte) 6, - (byte) 9, - (byte) 12, - (byte) 15, - (byte) 18, - (byte) 21, - (byte) 24, - (byte) 27, - (byte) 30, - (byte) 33, - (byte) 36, - (byte) 39, - (byte) 42, - (byte) 45, - (byte) 48, - (byte) 51, - (byte) 54, - (byte) 57, - (byte) 60, - (byte) 63, - (byte) 66, - (byte) 69, - (byte) 72, - (byte) 75, - (byte) 78, - (byte) 81, - (byte) 84, - (byte) 87, - (byte) 90, - (byte) 93, - (byte) 96, - (byte) 99, - (byte) 102, - (byte) 105, - (byte) 108, - (byte) 111, - (byte) 114, - (byte) 117, - (byte) 120, - (byte) 123, - (byte) 126, - (byte) 129, - (byte) 132, - (byte) 135, - (byte) 138, - (byte) 141, - (byte) 144, - (byte) 147, - (byte) 150, - (byte) 153, - (byte) 156, - (byte) 159, - (byte) 162, - (byte) 165, - (byte) 168, - (byte) 171, - (byte) 174, - (byte) 177, - (byte) 180, - (byte) 183, - (byte) 186, - (byte) 189, - (byte) 192, - (byte) 195, - (byte) 198, - (byte) 201, - (byte) 204, - (byte) 207, - (byte) 210, - (byte) 213, - (byte) 216, - (byte) 219, - (byte) 222, - (byte) 225, - (byte) 228, - (byte) 231, - (byte) 234, - (byte) 237, - (byte) 240, - (byte) 243, - (byte) 246, - (byte) 249, - (byte) 252, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xC02, payload); - MsgEd25519CertificateDep msg = new MsgEd25519CertificateDep(sbp); + System.out.format("%n%s%n", "auto_check_sbp_signing_MsgEd25519CertificateDepTest.test1"); + byte[] payload = new byte[] {(byte)16,(byte)100,(byte)101,(byte)102,(byte)103,(byte)104,(byte)105,(byte)106,(byte)107,(byte)108,(byte)109,(byte)110,(byte)111,(byte)112,(byte)113,(byte)114,(byte)115,(byte)116,(byte)117,(byte)118,(byte)119,(byte)0,(byte)3,(byte)6,(byte)9,(byte)12,(byte)15,(byte)18,(byte)21,(byte)24,(byte)27,(byte)30,(byte)33,(byte)36,(byte)39,(byte)42,(byte)45,(byte)48,(byte)51,(byte)54,(byte)57,(byte)60,(byte)63,(byte)66,(byte)69,(byte)72,(byte)75,(byte)78,(byte)81,(byte)84,(byte)87,(byte)90,(byte)93,(byte)96,(byte)99,(byte)102,(byte)105,(byte)108,(byte)111,(byte)114,(byte)117,(byte)120,(byte)123,(byte)126,(byte)129,(byte)132,(byte)135,(byte)138,(byte)141,(byte)144,(byte)147,(byte)150,(byte)153,(byte)156,(byte)159,(byte)162,(byte)165,(byte)168,(byte)171,(byte)174,(byte)177,(byte)180,(byte)183,(byte)186,(byte)189,(byte)192,(byte)195,(byte)198,(byte)201,(byte)204,(byte)207,(byte)210,(byte)213,(byte)216,(byte)219,(byte)222,(byte)225,(byte)228,(byte)231,(byte)234,(byte)237,(byte)240,(byte)243,(byte)246,(byte)249,(byte)252, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xC02, payload ); + MsgEd25519CertificateDep msg = new MsgEd25519CertificateDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.certificate_bytes[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -157,9 +50,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[1] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[1] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -167,9 +58,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[2] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[2] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -177,9 +66,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[3] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[3] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -187,9 +74,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[4] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[4] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -197,9 +82,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[5] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[5] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -207,9 +90,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[6] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[6] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -217,9 +98,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[7] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[7] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -227,9 +106,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[8] + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[8] + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -237,9 +114,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[9] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[9] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -247,9 +122,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[10] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[10] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -257,9 +130,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[11] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[11] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -267,9 +138,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[12] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[12] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -277,9 +146,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[13] + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[13] + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -287,9 +154,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[14] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[14] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -297,9 +162,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[15] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[15] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -307,9 +170,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[16] + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[16] + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -317,9 +178,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[17] + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[17] + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -327,9 +186,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[18] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[18] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -337,9 +194,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[19] + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[19] + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -347,9 +202,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[20] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[20] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -357,9 +210,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[21] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[21] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -367,9 +218,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[22] + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[22] + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -377,9 +226,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[23] + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[23] + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -387,9 +234,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[24] + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[24] + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -397,9 +242,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[25] + "' != '" + 75 + "'", - value.equals(BigInteger.valueOf(75L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[25] + "' != '" + 75 + "'", value.equals(BigInteger.valueOf( 75L ) ) ); } else { value = value.longValue(); expected = 75L; @@ -407,9 +250,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[26] + "' != '" + 78 + "'", - value.equals(BigInteger.valueOf(78L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[26] + "' != '" + 78 + "'", value.equals(BigInteger.valueOf( 78L ) ) ); } else { value = value.longValue(); expected = 78L; @@ -417,9 +258,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[27] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[27] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -427,9 +266,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[28] + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[28] + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -437,9 +274,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[29] + "' != '" + 87 + "'", - value.equals(BigInteger.valueOf(87L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[29] + "' != '" + 87 + "'", value.equals(BigInteger.valueOf( 87L ) ) ); } else { value = value.longValue(); expected = 87L; @@ -447,9 +282,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[30] + "' != '" + 90 + "'", - value.equals(BigInteger.valueOf(90L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[30] + "' != '" + 90 + "'", value.equals(BigInteger.valueOf( 90L ) ) ); } else { value = value.longValue(); expected = 90L; @@ -457,9 +290,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[31] + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[31] + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -467,9 +298,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[32] + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[32] + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -477,9 +306,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[33] + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[33] + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -487,9 +314,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[34] + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[34] + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -497,9 +322,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[35] + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[35] + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -507,9 +330,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[36] + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[36] + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -517,9 +338,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[37] + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[37] + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -527,9 +346,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[38] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[38] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -537,9 +354,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[39] + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[39] + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -547,9 +362,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[40] + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[40] + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -557,9 +370,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[41] + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[41] + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -567,9 +378,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[42] + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[42] + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -577,9 +386,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[43] + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[43] + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -587,9 +394,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[44] + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[44] + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -597,9 +402,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[45] + "' != '" + 135 + "'", - value.equals(BigInteger.valueOf(135L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[45] + "' != '" + 135 + "'", value.equals(BigInteger.valueOf( 135L ) ) ); } else { value = value.longValue(); expected = 135L; @@ -607,9 +410,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[46] + "' != '" + 138 + "'", - value.equals(BigInteger.valueOf(138L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[46] + "' != '" + 138 + "'", value.equals(BigInteger.valueOf( 138L ) ) ); } else { value = value.longValue(); expected = 138L; @@ -617,9 +418,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[47] + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[47] + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -627,9 +426,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[48] + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[48] + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -637,9 +434,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[49] + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[49] + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -647,9 +442,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[50] + "' != '" + 150 + "'", - value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[50] + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -657,9 +450,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[51] + "' != '" + 153 + "'", - value.equals(BigInteger.valueOf(153L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[51] + "' != '" + 153 + "'", value.equals(BigInteger.valueOf( 153L ) ) ); } else { value = value.longValue(); expected = 153L; @@ -667,9 +458,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[52] + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[52] + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -677,9 +466,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[53] + "' != '" + 159 + "'", - value.equals(BigInteger.valueOf(159L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[53] + "' != '" + 159 + "'", value.equals(BigInteger.valueOf( 159L ) ) ); } else { value = value.longValue(); expected = 159L; @@ -687,9 +474,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[54] + "' != '" + 162 + "'", - value.equals(BigInteger.valueOf(162L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[54] + "' != '" + 162 + "'", value.equals(BigInteger.valueOf( 162L ) ) ); } else { value = value.longValue(); expected = 162L; @@ -697,9 +482,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[55] + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[55] + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -707,9 +490,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[56] + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[56] + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -717,9 +498,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[57] + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[57] + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -727,9 +506,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[58] + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[58] + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -737,9 +514,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[59] + "' != '" + 177 + "'", - value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[59] + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -747,9 +522,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[60] + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[60] + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -757,9 +530,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[61] + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[61] + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -767,9 +538,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[62] + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[62] + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -777,9 +546,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[63] + "' != '" + 189 + "'", - value.equals(BigInteger.valueOf(189L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[63] + "' != '" + 189 + "'", value.equals(BigInteger.valueOf( 189L ) ) ); } else { value = value.longValue(); expected = 189L; @@ -787,9 +554,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[64]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[64] + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[64] + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -797,9 +562,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[65]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[65] + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[65] + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -807,9 +570,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[66]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[66] + "' != '" + 198 + "'", - value.equals(BigInteger.valueOf(198L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[66] + "' != '" + 198 + "'", value.equals(BigInteger.valueOf( 198L ) ) ); } else { value = value.longValue(); expected = 198L; @@ -817,9 +578,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[67]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[67] + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[67] + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -827,9 +586,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[68]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[68] + "' != '" + 204 + "'", - value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[68] + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -837,9 +594,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[69]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[69] + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[69] + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -847,9 +602,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[70]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[70] + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[70] + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -857,9 +610,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[71]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[71] + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[71] + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -867,9 +618,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[72]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[72] + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[72] + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -877,9 +626,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[73]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[73] + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[73] + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -887,9 +634,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[74]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[74] + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[74] + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -897,9 +642,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[75]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[75] + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[75] + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -907,9 +650,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[76]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[76] + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[76] + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -917,9 +658,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[77]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[77] + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[77] + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -927,9 +666,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[78]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[78] + "' != '" + 234 + "'", - value.equals(BigInteger.valueOf(234L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[78] + "' != '" + 234 + "'", value.equals(BigInteger.valueOf( 234L ) ) ); } else { value = value.longValue(); expected = 234L; @@ -937,9 +674,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[79]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[79] + "' != '" + 237 + "'", - value.equals(BigInteger.valueOf(237L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[79] + "' != '" + 237 + "'", value.equals(BigInteger.valueOf( 237L ) ) ); } else { value = value.longValue(); expected = 237L; @@ -947,9 +682,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[80]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[80] + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[80] + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -957,9 +690,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[81]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[81] + "' != '" + 243 + "'", - value.equals(BigInteger.valueOf(243L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[81] + "' != '" + 243 + "'", value.equals(BigInteger.valueOf( 243L ) ) ); } else { value = value.longValue(); expected = 243L; @@ -967,9 +698,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[82]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[82] + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[82] + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -977,9 +706,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[83]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[83] + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[83] + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -987,9 +714,7 @@ public void test1() throws Throwable { } value = msg.certificate_bytes[84]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.certificate_bytes[84] + "' != '" + 252 + "'", - value.equals(BigInteger.valueOf(252L))); + org.junit.Assert.assertTrue("'" + msg.certificate_bytes[84] + "' != '" + 252 + "'", value.equals(BigInteger.valueOf( 252L ) ) ); } else { value = value.longValue(); expected = 252L; @@ -997,9 +722,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[0] + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[0] + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -1007,9 +730,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[1] + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[1] + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -1017,9 +738,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[2] + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[2] + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -1027,9 +746,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[3] + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[3] + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -1037,9 +754,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[4] + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[4] + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -1047,9 +762,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[5] + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[5] + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -1057,9 +770,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[6] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[6] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -1067,9 +778,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[7] + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[7] + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -1077,9 +786,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[8] + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[8] + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -1087,9 +794,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[9] + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[9] + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -1097,9 +802,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[10] + "' != '" + 110 + "'", - value.equals(BigInteger.valueOf(110L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[10] + "' != '" + 110 + "'", value.equals(BigInteger.valueOf( 110L ) ) ); } else { value = value.longValue(); expected = 110L; @@ -1107,9 +810,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[11] + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[11] + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -1117,9 +818,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[12] + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[12] + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -1127,9 +826,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[13] + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[13] + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -1137,9 +834,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[14] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[14] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -1147,9 +842,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[15] + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[15] + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1157,9 +850,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[16] + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[16] + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1167,9 +858,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[17] + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[17] + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -1177,9 +866,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[18] + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[18] + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -1187,9 +874,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[19] + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[19] + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -1197,8 +882,7 @@ public void test1() throws Throwable { } value = msg.n_msg; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_msg + "' != '" + 16 + "'", value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.n_msg + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; diff --git a/java/test/auto_check_sbp_signing_MsgEd25519SignatureDepATest.java b/java/test/auto_check_sbp_signing_MsgEd25519SignatureDepATest.java index e7d1d7203..40e1b520c 100644 --- a/java/test/auto_check_sbp_signing_MsgEd25519SignatureDepATest.java +++ b/java/test/auto_check_sbp_signing_MsgEd25519SignatureDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/signing/test_MsgEd25519SignatureDepA.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/signing/test_MsgEd25519SignatureDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.signing.MsgEd25519SignatureDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_signing_MsgEd25519SignatureDepATest { @@ -30,203 +34,15 @@ public class auto_check_sbp_signing_MsgEd25519SignatureDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_signing_MsgEd25519SignatureDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 8, - (byte) 9, - (byte) 10, - (byte) 11, - (byte) 12, - (byte) 13, - (byte) 14, - (byte) 15, - (byte) 16, - (byte) 17, - (byte) 18, - (byte) 19, - (byte) 20, - (byte) 21, - (byte) 22, - (byte) 23, - (byte) 24, - (byte) 25, - (byte) 26, - (byte) 27, - (byte) 28, - (byte) 29, - (byte) 30, - (byte) 31, - (byte) 32, - (byte) 33, - (byte) 34, - (byte) 35, - (byte) 36, - (byte) 37, - (byte) 38, - (byte) 39, - (byte) 40, - (byte) 41, - (byte) 42, - (byte) 43, - (byte) 44, - (byte) 45, - (byte) 46, - (byte) 47, - (byte) 48, - (byte) 49, - (byte) 50, - (byte) 51, - (byte) 52, - (byte) 53, - (byte) 54, - (byte) 55, - (byte) 56, - (byte) 57, - (byte) 58, - (byte) 59, - (byte) 60, - (byte) 61, - (byte) 62, - (byte) 63, - (byte) 100, - (byte) 101, - (byte) 102, - (byte) 103, - (byte) 104, - (byte) 105, - (byte) 106, - (byte) 107, - (byte) 108, - (byte) 109, - (byte) 110, - (byte) 111, - (byte) 112, - (byte) 113, - (byte) 114, - (byte) 115, - (byte) 116, - (byte) 117, - (byte) 118, - (byte) 119, - (byte) 136, - (byte) 19, - (byte) 0, - (byte) 0, - (byte) 114, - (byte) 20, - (byte) 0, - (byte) 0, - (byte) 92, - (byte) 21, - (byte) 0, - (byte) 0, - (byte) 70, - (byte) 22, - (byte) 0, - (byte) 0, - (byte) 48, - (byte) 23, - (byte) 0, - (byte) 0, - (byte) 26, - (byte) 24, - (byte) 0, - (byte) 0, - (byte) 4, - (byte) 25, - (byte) 0, - (byte) 0, - (byte) 238, - (byte) 25, - (byte) 0, - (byte) 0, - (byte) 216, - (byte) 26, - (byte) 0, - (byte) 0, - (byte) 194, - (byte) 27, - (byte) 0, - (byte) 0, - (byte) 172, - (byte) 28, - (byte) 0, - (byte) 0, - (byte) 150, - (byte) 29, - (byte) 0, - (byte) 0, - (byte) 128, - (byte) 30, - (byte) 0, - (byte) 0, - (byte) 106, - (byte) 31, - (byte) 0, - (byte) 0, - (byte) 84, - (byte) 32, - (byte) 0, - (byte) 0, - (byte) 62, - (byte) 33, - (byte) 0, - (byte) 0, - (byte) 40, - (byte) 34, - (byte) 0, - (byte) 0, - (byte) 18, - (byte) 35, - (byte) 0, - (byte) 0, - (byte) 252, - (byte) 35, - (byte) 0, - (byte) 0, - (byte) 230, - (byte) 36, - (byte) 0, - (byte) 0, - (byte) 208, - (byte) 37, - (byte) 0, - (byte) 0, - (byte) 186, - (byte) 38, - (byte) 0, - (byte) 0, - (byte) 164, - (byte) 39, - (byte) 0, - (byte) 0, - (byte) 142, - (byte) 40, - (byte) 0, - (byte) 0, - (byte) 120, - (byte) 41, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xC01, payload); - MsgEd25519SignatureDepA msg = new MsgEd25519SignatureDepA(sbp); + byte[] payload = new byte[] {(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)8,(byte)9,(byte)10,(byte)11,(byte)12,(byte)13,(byte)14,(byte)15,(byte)16,(byte)17,(byte)18,(byte)19,(byte)20,(byte)21,(byte)22,(byte)23,(byte)24,(byte)25,(byte)26,(byte)27,(byte)28,(byte)29,(byte)30,(byte)31,(byte)32,(byte)33,(byte)34,(byte)35,(byte)36,(byte)37,(byte)38,(byte)39,(byte)40,(byte)41,(byte)42,(byte)43,(byte)44,(byte)45,(byte)46,(byte)47,(byte)48,(byte)49,(byte)50,(byte)51,(byte)52,(byte)53,(byte)54,(byte)55,(byte)56,(byte)57,(byte)58,(byte)59,(byte)60,(byte)61,(byte)62,(byte)63,(byte)100,(byte)101,(byte)102,(byte)103,(byte)104,(byte)105,(byte)106,(byte)107,(byte)108,(byte)109,(byte)110,(byte)111,(byte)112,(byte)113,(byte)114,(byte)115,(byte)116,(byte)117,(byte)118,(byte)119,(byte)136,(byte)19,(byte)0,(byte)0,(byte)114,(byte)20,(byte)0,(byte)0,(byte)92,(byte)21,(byte)0,(byte)0,(byte)70,(byte)22,(byte)0,(byte)0,(byte)48,(byte)23,(byte)0,(byte)0,(byte)26,(byte)24,(byte)0,(byte)0,(byte)4,(byte)25,(byte)0,(byte)0,(byte)238,(byte)25,(byte)0,(byte)0,(byte)216,(byte)26,(byte)0,(byte)0,(byte)194,(byte)27,(byte)0,(byte)0,(byte)172,(byte)28,(byte)0,(byte)0,(byte)150,(byte)29,(byte)0,(byte)0,(byte)128,(byte)30,(byte)0,(byte)0,(byte)106,(byte)31,(byte)0,(byte)0,(byte)84,(byte)32,(byte)0,(byte)0,(byte)62,(byte)33,(byte)0,(byte)0,(byte)40,(byte)34,(byte)0,(byte)0,(byte)18,(byte)35,(byte)0,(byte)0,(byte)252,(byte)35,(byte)0,(byte)0,(byte)230,(byte)36,(byte)0,(byte)0,(byte)208,(byte)37,(byte)0,(byte)0,(byte)186,(byte)38,(byte)0,(byte)0,(byte)164,(byte)39,(byte)0,(byte)0,(byte)142,(byte)40,(byte)0,(byte)0,(byte)120,(byte)41,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xC01, payload ); + MsgEd25519SignatureDepA msg = new MsgEd25519SignatureDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.fingerprint[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[0] + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[0] + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -234,9 +50,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[1] + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[1] + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -244,9 +58,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[2] + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[2] + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -254,9 +66,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[3] + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[3] + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -264,9 +74,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[4] + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[4] + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -274,9 +82,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[5] + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[5] + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -284,9 +90,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[6] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[6] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -294,9 +98,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[7] + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[7] + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -304,9 +106,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[8] + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[8] + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -314,9 +114,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[9] + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[9] + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -324,9 +122,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[10] + "' != '" + 110 + "'", - value.equals(BigInteger.valueOf(110L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[10] + "' != '" + 110 + "'", value.equals(BigInteger.valueOf( 110L ) ) ); } else { value = value.longValue(); expected = 110L; @@ -334,9 +130,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[11] + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[11] + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -344,9 +138,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[12] + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[12] + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -354,9 +146,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[13] + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[13] + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -364,9 +154,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[14] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[14] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -374,9 +162,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[15] + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[15] + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -384,9 +170,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[16] + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[16] + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -394,9 +178,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[17] + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[17] + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -404,9 +186,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[18] + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[18] + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -414,9 +194,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[19] + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[19] + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -424,9 +202,7 @@ public void test1() throws Throwable { } value = msg.signature[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -434,9 +210,7 @@ public void test1() throws Throwable { } value = msg.signature[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[1] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[1] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -444,9 +218,7 @@ public void test1() throws Throwable { } value = msg.signature[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[2] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[2] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -454,9 +226,7 @@ public void test1() throws Throwable { } value = msg.signature[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[3] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[3] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -464,9 +234,7 @@ public void test1() throws Throwable { } value = msg.signature[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[4] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[4] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -474,9 +242,7 @@ public void test1() throws Throwable { } value = msg.signature[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[5] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[5] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -484,9 +250,7 @@ public void test1() throws Throwable { } value = msg.signature[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[6] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[6] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -494,9 +258,7 @@ public void test1() throws Throwable { } value = msg.signature[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[7] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[7] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -504,9 +266,7 @@ public void test1() throws Throwable { } value = msg.signature[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[8] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.signature[8] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -514,9 +274,7 @@ public void test1() throws Throwable { } value = msg.signature[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[9] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.signature[9] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -524,9 +282,7 @@ public void test1() throws Throwable { } value = msg.signature[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[10] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.signature[10] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -534,9 +290,7 @@ public void test1() throws Throwable { } value = msg.signature[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[11] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.signature[11] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -544,9 +298,7 @@ public void test1() throws Throwable { } value = msg.signature[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[12] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.signature[12] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -554,9 +306,7 @@ public void test1() throws Throwable { } value = msg.signature[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[13] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.signature[13] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -564,9 +314,7 @@ public void test1() throws Throwable { } value = msg.signature[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[14] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.signature[14] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -574,9 +322,7 @@ public void test1() throws Throwable { } value = msg.signature[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[15] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.signature[15] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -584,9 +330,7 @@ public void test1() throws Throwable { } value = msg.signature[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[16] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.signature[16] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -594,9 +338,7 @@ public void test1() throws Throwable { } value = msg.signature[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[17] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.signature[17] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -604,9 +346,7 @@ public void test1() throws Throwable { } value = msg.signature[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[18] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.signature[18] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -614,9 +354,7 @@ public void test1() throws Throwable { } value = msg.signature[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[19] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.signature[19] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -624,9 +362,7 @@ public void test1() throws Throwable { } value = msg.signature[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[20] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.signature[20] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -634,9 +370,7 @@ public void test1() throws Throwable { } value = msg.signature[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[21] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.signature[21] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -644,9 +378,7 @@ public void test1() throws Throwable { } value = msg.signature[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[22] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.signature[22] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -654,9 +386,7 @@ public void test1() throws Throwable { } value = msg.signature[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[23] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.signature[23] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -664,9 +394,7 @@ public void test1() throws Throwable { } value = msg.signature[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[24] + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.signature[24] + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -674,9 +402,7 @@ public void test1() throws Throwable { } value = msg.signature[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[25] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.signature[25] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -684,9 +410,7 @@ public void test1() throws Throwable { } value = msg.signature[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[26] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.signature[26] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -694,9 +418,7 @@ public void test1() throws Throwable { } value = msg.signature[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[27] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.signature[27] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -704,9 +426,7 @@ public void test1() throws Throwable { } value = msg.signature[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[28] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.signature[28] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -714,9 +434,7 @@ public void test1() throws Throwable { } value = msg.signature[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[29] + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.signature[29] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -724,9 +442,7 @@ public void test1() throws Throwable { } value = msg.signature[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[30] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.signature[30] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -734,9 +450,7 @@ public void test1() throws Throwable { } value = msg.signature[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[31] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.signature[31] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -744,9 +458,7 @@ public void test1() throws Throwable { } value = msg.signature[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[32] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.signature[32] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -754,9 +466,7 @@ public void test1() throws Throwable { } value = msg.signature[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[33] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.signature[33] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -764,9 +474,7 @@ public void test1() throws Throwable { } value = msg.signature[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[34] + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.signature[34] + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -774,9 +482,7 @@ public void test1() throws Throwable { } value = msg.signature[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[35] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.signature[35] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -784,9 +490,7 @@ public void test1() throws Throwable { } value = msg.signature[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[36] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.signature[36] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -794,9 +498,7 @@ public void test1() throws Throwable { } value = msg.signature[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[37] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.signature[37] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -804,9 +506,7 @@ public void test1() throws Throwable { } value = msg.signature[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[38] + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.signature[38] + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -814,9 +514,7 @@ public void test1() throws Throwable { } value = msg.signature[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[39] + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.signature[39] + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -824,9 +522,7 @@ public void test1() throws Throwable { } value = msg.signature[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[40] + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.signature[40] + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -834,9 +530,7 @@ public void test1() throws Throwable { } value = msg.signature[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[41] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.signature[41] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -844,9 +538,7 @@ public void test1() throws Throwable { } value = msg.signature[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[42] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.signature[42] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -854,9 +546,7 @@ public void test1() throws Throwable { } value = msg.signature[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[43] + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.signature[43] + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -864,9 +554,7 @@ public void test1() throws Throwable { } value = msg.signature[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[44] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.signature[44] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -874,9 +562,7 @@ public void test1() throws Throwable { } value = msg.signature[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[45] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.signature[45] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -884,9 +570,7 @@ public void test1() throws Throwable { } value = msg.signature[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[46] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.signature[46] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -894,9 +578,7 @@ public void test1() throws Throwable { } value = msg.signature[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[47] + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.signature[47] + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -904,9 +586,7 @@ public void test1() throws Throwable { } value = msg.signature[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[48] + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.signature[48] + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -914,9 +594,7 @@ public void test1() throws Throwable { } value = msg.signature[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[49] + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.signature[49] + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -924,9 +602,7 @@ public void test1() throws Throwable { } value = msg.signature[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[50] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.signature[50] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -934,9 +610,7 @@ public void test1() throws Throwable { } value = msg.signature[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[51] + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.signature[51] + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -944,9 +618,7 @@ public void test1() throws Throwable { } value = msg.signature[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[52] + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.signature[52] + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -954,9 +626,7 @@ public void test1() throws Throwable { } value = msg.signature[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[53] + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.signature[53] + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -964,9 +634,7 @@ public void test1() throws Throwable { } value = msg.signature[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[54] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.signature[54] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -974,9 +642,7 @@ public void test1() throws Throwable { } value = msg.signature[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[55] + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.signature[55] + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -984,9 +650,7 @@ public void test1() throws Throwable { } value = msg.signature[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[56] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.signature[56] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -994,9 +658,7 @@ public void test1() throws Throwable { } value = msg.signature[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[57] + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.signature[57] + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -1004,9 +666,7 @@ public void test1() throws Throwable { } value = msg.signature[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[58] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.signature[58] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -1014,9 +674,7 @@ public void test1() throws Throwable { } value = msg.signature[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[59] + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.signature[59] + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -1024,9 +682,7 @@ public void test1() throws Throwable { } value = msg.signature[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[60] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.signature[60] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -1034,9 +690,7 @@ public void test1() throws Throwable { } value = msg.signature[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[61] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.signature[61] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -1044,9 +698,7 @@ public void test1() throws Throwable { } value = msg.signature[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[62] + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.signature[62] + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -1054,9 +706,7 @@ public void test1() throws Throwable { } value = msg.signature[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[63] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.signature[63] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -1064,9 +714,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[0] + "' != '" + 5000 + "'", - value.equals(BigInteger.valueOf(5000L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[0] + "' != '" + 5000 + "'", value.equals(BigInteger.valueOf( 5000L ) ) ); } else { value = value.longValue(); expected = 5000L; @@ -1074,9 +722,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[1] + "' != '" + 5234 + "'", - value.equals(BigInteger.valueOf(5234L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[1] + "' != '" + 5234 + "'", value.equals(BigInteger.valueOf( 5234L ) ) ); } else { value = value.longValue(); expected = 5234L; @@ -1084,9 +730,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[2] + "' != '" + 5468 + "'", - value.equals(BigInteger.valueOf(5468L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[2] + "' != '" + 5468 + "'", value.equals(BigInteger.valueOf( 5468L ) ) ); } else { value = value.longValue(); expected = 5468L; @@ -1094,9 +738,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[3] + "' != '" + 5702 + "'", - value.equals(BigInteger.valueOf(5702L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[3] + "' != '" + 5702 + "'", value.equals(BigInteger.valueOf( 5702L ) ) ); } else { value = value.longValue(); expected = 5702L; @@ -1104,9 +746,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[4] + "' != '" + 5936 + "'", - value.equals(BigInteger.valueOf(5936L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[4] + "' != '" + 5936 + "'", value.equals(BigInteger.valueOf( 5936L ) ) ); } else { value = value.longValue(); expected = 5936L; @@ -1114,9 +754,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[5] + "' != '" + 6170 + "'", - value.equals(BigInteger.valueOf(6170L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[5] + "' != '" + 6170 + "'", value.equals(BigInteger.valueOf( 6170L ) ) ); } else { value = value.longValue(); expected = 6170L; @@ -1124,9 +762,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[6] + "' != '" + 6404 + "'", - value.equals(BigInteger.valueOf(6404L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[6] + "' != '" + 6404 + "'", value.equals(BigInteger.valueOf( 6404L ) ) ); } else { value = value.longValue(); expected = 6404L; @@ -1134,9 +770,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[7] + "' != '" + 6638 + "'", - value.equals(BigInteger.valueOf(6638L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[7] + "' != '" + 6638 + "'", value.equals(BigInteger.valueOf( 6638L ) ) ); } else { value = value.longValue(); expected = 6638L; @@ -1144,9 +778,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[8] + "' != '" + 6872 + "'", - value.equals(BigInteger.valueOf(6872L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[8] + "' != '" + 6872 + "'", value.equals(BigInteger.valueOf( 6872L ) ) ); } else { value = value.longValue(); expected = 6872L; @@ -1154,9 +786,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[9] + "' != '" + 7106 + "'", - value.equals(BigInteger.valueOf(7106L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[9] + "' != '" + 7106 + "'", value.equals(BigInteger.valueOf( 7106L ) ) ); } else { value = value.longValue(); expected = 7106L; @@ -1164,9 +794,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[10] + "' != '" + 7340 + "'", - value.equals(BigInteger.valueOf(7340L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[10] + "' != '" + 7340 + "'", value.equals(BigInteger.valueOf( 7340L ) ) ); } else { value = value.longValue(); expected = 7340L; @@ -1174,9 +802,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[11] + "' != '" + 7574 + "'", - value.equals(BigInteger.valueOf(7574L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[11] + "' != '" + 7574 + "'", value.equals(BigInteger.valueOf( 7574L ) ) ); } else { value = value.longValue(); expected = 7574L; @@ -1184,9 +810,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[12] + "' != '" + 7808 + "'", - value.equals(BigInteger.valueOf(7808L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[12] + "' != '" + 7808 + "'", value.equals(BigInteger.valueOf( 7808L ) ) ); } else { value = value.longValue(); expected = 7808L; @@ -1194,9 +818,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[13] + "' != '" + 8042 + "'", - value.equals(BigInteger.valueOf(8042L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[13] + "' != '" + 8042 + "'", value.equals(BigInteger.valueOf( 8042L ) ) ); } else { value = value.longValue(); expected = 8042L; @@ -1204,9 +826,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[14] + "' != '" + 8276 + "'", - value.equals(BigInteger.valueOf(8276L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[14] + "' != '" + 8276 + "'", value.equals(BigInteger.valueOf( 8276L ) ) ); } else { value = value.longValue(); expected = 8276L; @@ -1214,9 +834,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[15] + "' != '" + 8510 + "'", - value.equals(BigInteger.valueOf(8510L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[15] + "' != '" + 8510 + "'", value.equals(BigInteger.valueOf( 8510L ) ) ); } else { value = value.longValue(); expected = 8510L; @@ -1224,9 +842,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[16] + "' != '" + 8744 + "'", - value.equals(BigInteger.valueOf(8744L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[16] + "' != '" + 8744 + "'", value.equals(BigInteger.valueOf( 8744L ) ) ); } else { value = value.longValue(); expected = 8744L; @@ -1234,9 +850,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[17] + "' != '" + 8978 + "'", - value.equals(BigInteger.valueOf(8978L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[17] + "' != '" + 8978 + "'", value.equals(BigInteger.valueOf( 8978L ) ) ); } else { value = value.longValue(); expected = 8978L; @@ -1244,9 +858,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[18] + "' != '" + 9212 + "'", - value.equals(BigInteger.valueOf(9212L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[18] + "' != '" + 9212 + "'", value.equals(BigInteger.valueOf( 9212L ) ) ); } else { value = value.longValue(); expected = 9212L; @@ -1254,9 +866,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[19] + "' != '" + 9446 + "'", - value.equals(BigInteger.valueOf(9446L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[19] + "' != '" + 9446 + "'", value.equals(BigInteger.valueOf( 9446L ) ) ); } else { value = value.longValue(); expected = 9446L; @@ -1264,9 +874,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[20] + "' != '" + 9680 + "'", - value.equals(BigInteger.valueOf(9680L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[20] + "' != '" + 9680 + "'", value.equals(BigInteger.valueOf( 9680L ) ) ); } else { value = value.longValue(); expected = 9680L; @@ -1274,9 +882,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[21] + "' != '" + 9914 + "'", - value.equals(BigInteger.valueOf(9914L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[21] + "' != '" + 9914 + "'", value.equals(BigInteger.valueOf( 9914L ) ) ); } else { value = value.longValue(); expected = 9914L; @@ -1284,9 +890,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[22] + "' != '" + 10148 + "'", - value.equals(BigInteger.valueOf(10148L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[22] + "' != '" + 10148 + "'", value.equals(BigInteger.valueOf( 10148L ) ) ); } else { value = value.longValue(); expected = 10148L; @@ -1294,9 +898,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[23] + "' != '" + 10382 + "'", - value.equals(BigInteger.valueOf(10382L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[23] + "' != '" + 10382 + "'", value.equals(BigInteger.valueOf( 10382L ) ) ); } else { value = value.longValue(); expected = 10382L; @@ -1304,9 +906,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[24] + "' != '" + 10616 + "'", - value.equals(BigInteger.valueOf(10616L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[24] + "' != '" + 10616 + "'", value.equals(BigInteger.valueOf( 10616L ) ) ); } else { value = value.longValue(); expected = 10616L; diff --git a/java/test/auto_check_sbp_signing_MsgEd25519SignatureDepBTest.java b/java/test/auto_check_sbp_signing_MsgEd25519SignatureDepBTest.java index 507eef6e5..20682333a 100644 --- a/java/test/auto_check_sbp_signing_MsgEd25519SignatureDepBTest.java +++ b/java/test/auto_check_sbp_signing_MsgEd25519SignatureDepBTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/signing/test_MsgEd25519SignatureDepB.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/signing/test_MsgEd25519SignatureDepB.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.signing.MsgEd25519SignatureDepB; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_signing_MsgEd25519SignatureDepBTest { @@ -30,205 +34,15 @@ public class auto_check_sbp_signing_MsgEd25519SignatureDepBTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_signing_MsgEd25519SignatureDepBTest.test1"); - byte[] payload = - new byte[] { - (byte) 1, - (byte) 0, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 4, - (byte) 5, - (byte) 6, - (byte) 7, - (byte) 8, - (byte) 9, - (byte) 10, - (byte) 11, - (byte) 12, - (byte) 13, - (byte) 14, - (byte) 15, - (byte) 16, - (byte) 17, - (byte) 18, - (byte) 19, - (byte) 20, - (byte) 21, - (byte) 22, - (byte) 23, - (byte) 24, - (byte) 25, - (byte) 26, - (byte) 27, - (byte) 28, - (byte) 29, - (byte) 30, - (byte) 31, - (byte) 32, - (byte) 33, - (byte) 34, - (byte) 35, - (byte) 36, - (byte) 37, - (byte) 38, - (byte) 39, - (byte) 40, - (byte) 41, - (byte) 42, - (byte) 43, - (byte) 44, - (byte) 45, - (byte) 46, - (byte) 47, - (byte) 48, - (byte) 49, - (byte) 50, - (byte) 51, - (byte) 52, - (byte) 53, - (byte) 54, - (byte) 55, - (byte) 56, - (byte) 57, - (byte) 58, - (byte) 59, - (byte) 60, - (byte) 61, - (byte) 62, - (byte) 63, - (byte) 100, - (byte) 101, - (byte) 102, - (byte) 103, - (byte) 104, - (byte) 105, - (byte) 106, - (byte) 107, - (byte) 108, - (byte) 109, - (byte) 110, - (byte) 111, - (byte) 112, - (byte) 113, - (byte) 114, - (byte) 115, - (byte) 116, - (byte) 117, - (byte) 118, - (byte) 119, - (byte) 136, - (byte) 19, - (byte) 0, - (byte) 0, - (byte) 114, - (byte) 20, - (byte) 0, - (byte) 0, - (byte) 92, - (byte) 21, - (byte) 0, - (byte) 0, - (byte) 70, - (byte) 22, - (byte) 0, - (byte) 0, - (byte) 48, - (byte) 23, - (byte) 0, - (byte) 0, - (byte) 26, - (byte) 24, - (byte) 0, - (byte) 0, - (byte) 4, - (byte) 25, - (byte) 0, - (byte) 0, - (byte) 238, - (byte) 25, - (byte) 0, - (byte) 0, - (byte) 216, - (byte) 26, - (byte) 0, - (byte) 0, - (byte) 194, - (byte) 27, - (byte) 0, - (byte) 0, - (byte) 172, - (byte) 28, - (byte) 0, - (byte) 0, - (byte) 150, - (byte) 29, - (byte) 0, - (byte) 0, - (byte) 128, - (byte) 30, - (byte) 0, - (byte) 0, - (byte) 106, - (byte) 31, - (byte) 0, - (byte) 0, - (byte) 84, - (byte) 32, - (byte) 0, - (byte) 0, - (byte) 62, - (byte) 33, - (byte) 0, - (byte) 0, - (byte) 40, - (byte) 34, - (byte) 0, - (byte) 0, - (byte) 18, - (byte) 35, - (byte) 0, - (byte) 0, - (byte) 252, - (byte) 35, - (byte) 0, - (byte) 0, - (byte) 230, - (byte) 36, - (byte) 0, - (byte) 0, - (byte) 208, - (byte) 37, - (byte) 0, - (byte) 0, - (byte) 186, - (byte) 38, - (byte) 0, - (byte) 0, - (byte) 164, - (byte) 39, - (byte) 0, - (byte) 0, - (byte) 142, - (byte) 40, - (byte) 0, - (byte) 0, - (byte) 120, - (byte) 41, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xC03, payload); - MsgEd25519SignatureDepB msg = new MsgEd25519SignatureDepB(sbp); + byte[] payload = new byte[] {(byte)1,(byte)0,(byte)0,(byte)1,(byte)2,(byte)3,(byte)4,(byte)5,(byte)6,(byte)7,(byte)8,(byte)9,(byte)10,(byte)11,(byte)12,(byte)13,(byte)14,(byte)15,(byte)16,(byte)17,(byte)18,(byte)19,(byte)20,(byte)21,(byte)22,(byte)23,(byte)24,(byte)25,(byte)26,(byte)27,(byte)28,(byte)29,(byte)30,(byte)31,(byte)32,(byte)33,(byte)34,(byte)35,(byte)36,(byte)37,(byte)38,(byte)39,(byte)40,(byte)41,(byte)42,(byte)43,(byte)44,(byte)45,(byte)46,(byte)47,(byte)48,(byte)49,(byte)50,(byte)51,(byte)52,(byte)53,(byte)54,(byte)55,(byte)56,(byte)57,(byte)58,(byte)59,(byte)60,(byte)61,(byte)62,(byte)63,(byte)100,(byte)101,(byte)102,(byte)103,(byte)104,(byte)105,(byte)106,(byte)107,(byte)108,(byte)109,(byte)110,(byte)111,(byte)112,(byte)113,(byte)114,(byte)115,(byte)116,(byte)117,(byte)118,(byte)119,(byte)136,(byte)19,(byte)0,(byte)0,(byte)114,(byte)20,(byte)0,(byte)0,(byte)92,(byte)21,(byte)0,(byte)0,(byte)70,(byte)22,(byte)0,(byte)0,(byte)48,(byte)23,(byte)0,(byte)0,(byte)26,(byte)24,(byte)0,(byte)0,(byte)4,(byte)25,(byte)0,(byte)0,(byte)238,(byte)25,(byte)0,(byte)0,(byte)216,(byte)26,(byte)0,(byte)0,(byte)194,(byte)27,(byte)0,(byte)0,(byte)172,(byte)28,(byte)0,(byte)0,(byte)150,(byte)29,(byte)0,(byte)0,(byte)128,(byte)30,(byte)0,(byte)0,(byte)106,(byte)31,(byte)0,(byte)0,(byte)84,(byte)32,(byte)0,(byte)0,(byte)62,(byte)33,(byte)0,(byte)0,(byte)40,(byte)34,(byte)0,(byte)0,(byte)18,(byte)35,(byte)0,(byte)0,(byte)252,(byte)35,(byte)0,(byte)0,(byte)230,(byte)36,(byte)0,(byte)0,(byte)208,(byte)37,(byte)0,(byte)0,(byte)186,(byte)38,(byte)0,(byte)0,(byte)164,(byte)39,(byte)0,(byte)0,(byte)142,(byte)40,(byte)0,(byte)0,(byte)120,(byte)41,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xC03, payload ); + MsgEd25519SignatureDepB msg = new MsgEd25519SignatureDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.fingerprint[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[0] + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[0] + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -236,9 +50,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[1] + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[1] + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -246,9 +58,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[2] + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[2] + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -256,9 +66,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[3] + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[3] + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -266,9 +74,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[4] + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[4] + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -276,9 +82,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[5] + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[5] + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -286,9 +90,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[6] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[6] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -296,9 +98,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[7] + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[7] + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -306,9 +106,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[8] + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[8] + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -316,9 +114,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[9] + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[9] + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -326,9 +122,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[10] + "' != '" + 110 + "'", - value.equals(BigInteger.valueOf(110L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[10] + "' != '" + 110 + "'", value.equals(BigInteger.valueOf( 110L ) ) ); } else { value = value.longValue(); expected = 110L; @@ -336,9 +130,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[11] + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[11] + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -346,9 +138,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[12] + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[12] + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -356,9 +146,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[13] + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[13] + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -366,9 +154,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[14] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[14] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -376,9 +162,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[15] + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[15] + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -386,9 +170,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[16] + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[16] + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -396,9 +178,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[17] + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[17] + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -406,9 +186,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[18] + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[18] + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -416,9 +194,7 @@ public void test1() throws Throwable { } value = msg.fingerprint[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.fingerprint[19] + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.fingerprint[19] + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -426,9 +202,7 @@ public void test1() throws Throwable { } value = msg.on_demand_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.on_demand_counter + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.on_demand_counter + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -436,9 +210,7 @@ public void test1() throws Throwable { } value = msg.signature[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[0] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.signature[0] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -446,9 +218,7 @@ public void test1() throws Throwable { } value = msg.signature[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[1] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.signature[1] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -456,9 +226,7 @@ public void test1() throws Throwable { } value = msg.signature[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[2] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.signature[2] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -466,9 +234,7 @@ public void test1() throws Throwable { } value = msg.signature[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[3] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.signature[3] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -476,9 +242,7 @@ public void test1() throws Throwable { } value = msg.signature[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[4] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.signature[4] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -486,9 +250,7 @@ public void test1() throws Throwable { } value = msg.signature[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[5] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.signature[5] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -496,9 +258,7 @@ public void test1() throws Throwable { } value = msg.signature[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[6] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.signature[6] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -506,9 +266,7 @@ public void test1() throws Throwable { } value = msg.signature[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[7] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.signature[7] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -516,9 +274,7 @@ public void test1() throws Throwable { } value = msg.signature[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[8] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.signature[8] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -526,9 +282,7 @@ public void test1() throws Throwable { } value = msg.signature[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[9] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.signature[9] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -536,9 +290,7 @@ public void test1() throws Throwable { } value = msg.signature[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[10] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.signature[10] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -546,9 +298,7 @@ public void test1() throws Throwable { } value = msg.signature[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[11] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.signature[11] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -556,9 +306,7 @@ public void test1() throws Throwable { } value = msg.signature[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[12] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.signature[12] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -566,9 +314,7 @@ public void test1() throws Throwable { } value = msg.signature[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[13] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.signature[13] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -576,9 +322,7 @@ public void test1() throws Throwable { } value = msg.signature[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[14] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.signature[14] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -586,9 +330,7 @@ public void test1() throws Throwable { } value = msg.signature[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[15] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.signature[15] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -596,9 +338,7 @@ public void test1() throws Throwable { } value = msg.signature[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[16] + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.signature[16] + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -606,9 +346,7 @@ public void test1() throws Throwable { } value = msg.signature[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[17] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.signature[17] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -616,9 +354,7 @@ public void test1() throws Throwable { } value = msg.signature[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[18] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.signature[18] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -626,9 +362,7 @@ public void test1() throws Throwable { } value = msg.signature[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[19] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.signature[19] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -636,9 +370,7 @@ public void test1() throws Throwable { } value = msg.signature[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[20] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.signature[20] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -646,9 +378,7 @@ public void test1() throws Throwable { } value = msg.signature[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[21] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.signature[21] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -656,9 +386,7 @@ public void test1() throws Throwable { } value = msg.signature[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[22] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.signature[22] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -666,9 +394,7 @@ public void test1() throws Throwable { } value = msg.signature[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[23] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.signature[23] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -676,9 +402,7 @@ public void test1() throws Throwable { } value = msg.signature[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[24] + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.signature[24] + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -686,9 +410,7 @@ public void test1() throws Throwable { } value = msg.signature[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[25] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.signature[25] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -696,9 +418,7 @@ public void test1() throws Throwable { } value = msg.signature[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[26] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.signature[26] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -706,9 +426,7 @@ public void test1() throws Throwable { } value = msg.signature[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[27] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.signature[27] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -716,9 +434,7 @@ public void test1() throws Throwable { } value = msg.signature[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[28] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.signature[28] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -726,9 +442,7 @@ public void test1() throws Throwable { } value = msg.signature[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[29] + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.signature[29] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -736,9 +450,7 @@ public void test1() throws Throwable { } value = msg.signature[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[30] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.signature[30] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -746,9 +458,7 @@ public void test1() throws Throwable { } value = msg.signature[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[31] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.signature[31] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -756,9 +466,7 @@ public void test1() throws Throwable { } value = msg.signature[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[32] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.signature[32] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -766,9 +474,7 @@ public void test1() throws Throwable { } value = msg.signature[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[33] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.signature[33] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -776,9 +482,7 @@ public void test1() throws Throwable { } value = msg.signature[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[34] + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.signature[34] + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -786,9 +490,7 @@ public void test1() throws Throwable { } value = msg.signature[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[35] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.signature[35] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -796,9 +498,7 @@ public void test1() throws Throwable { } value = msg.signature[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[36] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.signature[36] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -806,9 +506,7 @@ public void test1() throws Throwable { } value = msg.signature[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[37] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.signature[37] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -816,9 +514,7 @@ public void test1() throws Throwable { } value = msg.signature[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[38] + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.signature[38] + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -826,9 +522,7 @@ public void test1() throws Throwable { } value = msg.signature[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[39] + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.signature[39] + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -836,9 +530,7 @@ public void test1() throws Throwable { } value = msg.signature[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[40] + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.signature[40] + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -846,9 +538,7 @@ public void test1() throws Throwable { } value = msg.signature[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[41] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.signature[41] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -856,9 +546,7 @@ public void test1() throws Throwable { } value = msg.signature[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[42] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.signature[42] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -866,9 +554,7 @@ public void test1() throws Throwable { } value = msg.signature[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[43] + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.signature[43] + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -876,9 +562,7 @@ public void test1() throws Throwable { } value = msg.signature[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[44] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.signature[44] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -886,9 +570,7 @@ public void test1() throws Throwable { } value = msg.signature[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[45] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.signature[45] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -896,9 +578,7 @@ public void test1() throws Throwable { } value = msg.signature[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[46] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.signature[46] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -906,9 +586,7 @@ public void test1() throws Throwable { } value = msg.signature[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[47] + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.signature[47] + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -916,9 +594,7 @@ public void test1() throws Throwable { } value = msg.signature[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[48] + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.signature[48] + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -926,9 +602,7 @@ public void test1() throws Throwable { } value = msg.signature[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[49] + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.signature[49] + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -936,9 +610,7 @@ public void test1() throws Throwable { } value = msg.signature[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[50] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.signature[50] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -946,9 +618,7 @@ public void test1() throws Throwable { } value = msg.signature[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[51] + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.signature[51] + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -956,9 +626,7 @@ public void test1() throws Throwable { } value = msg.signature[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[52] + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.signature[52] + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -966,9 +634,7 @@ public void test1() throws Throwable { } value = msg.signature[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[53] + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.signature[53] + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -976,9 +642,7 @@ public void test1() throws Throwable { } value = msg.signature[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[54] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.signature[54] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -986,9 +650,7 @@ public void test1() throws Throwable { } value = msg.signature[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[55] + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.signature[55] + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -996,9 +658,7 @@ public void test1() throws Throwable { } value = msg.signature[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[56] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.signature[56] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -1006,9 +666,7 @@ public void test1() throws Throwable { } value = msg.signature[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[57] + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.signature[57] + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -1016,9 +674,7 @@ public void test1() throws Throwable { } value = msg.signature[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[58] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.signature[58] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -1026,9 +682,7 @@ public void test1() throws Throwable { } value = msg.signature[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[59] + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.signature[59] + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -1036,9 +690,7 @@ public void test1() throws Throwable { } value = msg.signature[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[60] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.signature[60] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -1046,9 +698,7 @@ public void test1() throws Throwable { } value = msg.signature[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[61] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.signature[61] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -1056,9 +706,7 @@ public void test1() throws Throwable { } value = msg.signature[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[62] + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.signature[62] + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -1066,9 +714,7 @@ public void test1() throws Throwable { } value = msg.signature[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signature[63] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.signature[63] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -1076,9 +722,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[0] + "' != '" + 5000 + "'", - value.equals(BigInteger.valueOf(5000L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[0] + "' != '" + 5000 + "'", value.equals(BigInteger.valueOf( 5000L ) ) ); } else { value = value.longValue(); expected = 5000L; @@ -1086,9 +730,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[1] + "' != '" + 5234 + "'", - value.equals(BigInteger.valueOf(5234L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[1] + "' != '" + 5234 + "'", value.equals(BigInteger.valueOf( 5234L ) ) ); } else { value = value.longValue(); expected = 5234L; @@ -1096,9 +738,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[2] + "' != '" + 5468 + "'", - value.equals(BigInteger.valueOf(5468L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[2] + "' != '" + 5468 + "'", value.equals(BigInteger.valueOf( 5468L ) ) ); } else { value = value.longValue(); expected = 5468L; @@ -1106,9 +746,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[3] + "' != '" + 5702 + "'", - value.equals(BigInteger.valueOf(5702L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[3] + "' != '" + 5702 + "'", value.equals(BigInteger.valueOf( 5702L ) ) ); } else { value = value.longValue(); expected = 5702L; @@ -1116,9 +754,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[4] + "' != '" + 5936 + "'", - value.equals(BigInteger.valueOf(5936L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[4] + "' != '" + 5936 + "'", value.equals(BigInteger.valueOf( 5936L ) ) ); } else { value = value.longValue(); expected = 5936L; @@ -1126,9 +762,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[5] + "' != '" + 6170 + "'", - value.equals(BigInteger.valueOf(6170L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[5] + "' != '" + 6170 + "'", value.equals(BigInteger.valueOf( 6170L ) ) ); } else { value = value.longValue(); expected = 6170L; @@ -1136,9 +770,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[6] + "' != '" + 6404 + "'", - value.equals(BigInteger.valueOf(6404L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[6] + "' != '" + 6404 + "'", value.equals(BigInteger.valueOf( 6404L ) ) ); } else { value = value.longValue(); expected = 6404L; @@ -1146,9 +778,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[7] + "' != '" + 6638 + "'", - value.equals(BigInteger.valueOf(6638L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[7] + "' != '" + 6638 + "'", value.equals(BigInteger.valueOf( 6638L ) ) ); } else { value = value.longValue(); expected = 6638L; @@ -1156,9 +786,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[8] + "' != '" + 6872 + "'", - value.equals(BigInteger.valueOf(6872L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[8] + "' != '" + 6872 + "'", value.equals(BigInteger.valueOf( 6872L ) ) ); } else { value = value.longValue(); expected = 6872L; @@ -1166,9 +794,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[9] + "' != '" + 7106 + "'", - value.equals(BigInteger.valueOf(7106L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[9] + "' != '" + 7106 + "'", value.equals(BigInteger.valueOf( 7106L ) ) ); } else { value = value.longValue(); expected = 7106L; @@ -1176,9 +802,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[10] + "' != '" + 7340 + "'", - value.equals(BigInteger.valueOf(7340L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[10] + "' != '" + 7340 + "'", value.equals(BigInteger.valueOf( 7340L ) ) ); } else { value = value.longValue(); expected = 7340L; @@ -1186,9 +810,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[11] + "' != '" + 7574 + "'", - value.equals(BigInteger.valueOf(7574L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[11] + "' != '" + 7574 + "'", value.equals(BigInteger.valueOf( 7574L ) ) ); } else { value = value.longValue(); expected = 7574L; @@ -1196,9 +818,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[12] + "' != '" + 7808 + "'", - value.equals(BigInteger.valueOf(7808L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[12] + "' != '" + 7808 + "'", value.equals(BigInteger.valueOf( 7808L ) ) ); } else { value = value.longValue(); expected = 7808L; @@ -1206,9 +826,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[13] + "' != '" + 8042 + "'", - value.equals(BigInteger.valueOf(8042L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[13] + "' != '" + 8042 + "'", value.equals(BigInteger.valueOf( 8042L ) ) ); } else { value = value.longValue(); expected = 8042L; @@ -1216,9 +834,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[14] + "' != '" + 8276 + "'", - value.equals(BigInteger.valueOf(8276L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[14] + "' != '" + 8276 + "'", value.equals(BigInteger.valueOf( 8276L ) ) ); } else { value = value.longValue(); expected = 8276L; @@ -1226,9 +842,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[15] + "' != '" + 8510 + "'", - value.equals(BigInteger.valueOf(8510L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[15] + "' != '" + 8510 + "'", value.equals(BigInteger.valueOf( 8510L ) ) ); } else { value = value.longValue(); expected = 8510L; @@ -1236,9 +850,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[16] + "' != '" + 8744 + "'", - value.equals(BigInteger.valueOf(8744L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[16] + "' != '" + 8744 + "'", value.equals(BigInteger.valueOf( 8744L ) ) ); } else { value = value.longValue(); expected = 8744L; @@ -1246,9 +858,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[17] + "' != '" + 8978 + "'", - value.equals(BigInteger.valueOf(8978L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[17] + "' != '" + 8978 + "'", value.equals(BigInteger.valueOf( 8978L ) ) ); } else { value = value.longValue(); expected = 8978L; @@ -1256,9 +866,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[18] + "' != '" + 9212 + "'", - value.equals(BigInteger.valueOf(9212L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[18] + "' != '" + 9212 + "'", value.equals(BigInteger.valueOf( 9212L ) ) ); } else { value = value.longValue(); expected = 9212L; @@ -1266,9 +874,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[19] + "' != '" + 9446 + "'", - value.equals(BigInteger.valueOf(9446L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[19] + "' != '" + 9446 + "'", value.equals(BigInteger.valueOf( 9446L ) ) ); } else { value = value.longValue(); expected = 9446L; @@ -1276,9 +882,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[20] + "' != '" + 9680 + "'", - value.equals(BigInteger.valueOf(9680L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[20] + "' != '" + 9680 + "'", value.equals(BigInteger.valueOf( 9680L ) ) ); } else { value = value.longValue(); expected = 9680L; @@ -1286,9 +890,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[21] + "' != '" + 9914 + "'", - value.equals(BigInteger.valueOf(9914L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[21] + "' != '" + 9914 + "'", value.equals(BigInteger.valueOf( 9914L ) ) ); } else { value = value.longValue(); expected = 9914L; @@ -1296,9 +898,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[22] + "' != '" + 10148 + "'", - value.equals(BigInteger.valueOf(10148L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[22] + "' != '" + 10148 + "'", value.equals(BigInteger.valueOf( 10148L ) ) ); } else { value = value.longValue(); expected = 10148L; @@ -1306,9 +906,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[23] + "' != '" + 10382 + "'", - value.equals(BigInteger.valueOf(10382L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[23] + "' != '" + 10382 + "'", value.equals(BigInteger.valueOf( 10382L ) ) ); } else { value = value.longValue(); expected = 10382L; @@ -1316,9 +914,7 @@ public void test1() throws Throwable { } value = msg.signed_messages[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.signed_messages[24] + "' != '" + 10616 + "'", - value.equals(BigInteger.valueOf(10616L))); + org.junit.Assert.assertTrue("'" + msg.signed_messages[24] + "' != '" + 10616 + "'", value.equals(BigInteger.valueOf( 10616L ) ) ); } else { value = value.longValue(); expected = 10616L; @@ -1326,9 +922,7 @@ public void test1() throws Throwable { } value = msg.stream_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stream_counter + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.stream_counter + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; diff --git a/java/test/auto_check_sbp_signing_signing_structsTest.java b/java/test/auto_check_sbp_signing_signing_structsTest.java index 2e30779e7..c8cde2805 100644 --- a/java/test/auto_check_sbp_signing_signing_structsTest.java +++ b/java/test/auto_check_sbp_signing_signing_structsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,10 +9,19 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/signing/test_signing_structs.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/signing/test_signing_structs.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; + +import org.json.JSONObject; + +import com.swiftnav.sbp.SBPMessage; + public class auto_check_sbp_signing_signing_structsTest { diff --git a/java/test/auto_check_sbp_soln_meta_soln_meta_structsTest.java b/java/test/auto_check_sbp_soln_meta_soln_meta_structsTest.java index 587146618..80ceddffe 100644 --- a/java/test/auto_check_sbp_soln_meta_soln_meta_structsTest.java +++ b/java/test/auto_check_sbp_soln_meta_soln_meta_structsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,11 +9,19 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/soln_meta/test_soln_meta_structs.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/soln_meta/test_soln_meta_structs.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; + +import org.json.JSONObject; + +import com.swiftnav.sbp.SBPMessage; + public class auto_check_sbp_soln_meta_soln_meta_structsTest { diff --git a/java/test/auto_check_sbp_solution_meta_MsgSolnMetaDepATest.java b/java/test/auto_check_sbp_solution_meta_MsgSolnMetaDepATest.java index f0649f156..1f20dcefc 100644 --- a/java/test/auto_check_sbp_solution_meta_MsgSolnMetaDepATest.java +++ b/java/test/auto_check_sbp_solution_meta_MsgSolnMetaDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/soln_meta/test_MsgSolnMetaDepA.yaml by generate.py. Do not modify by -// hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/soln_meta/test_MsgSolnMetaDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.solution_meta.MsgSolnMetaDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_solution_meta_MsgSolnMetaDepATest { @@ -30,273 +34,15 @@ public class auto_check_sbp_solution_meta_MsgSolnMetaDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_solution_meta_MsgSolnMetaDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 183, - (byte) 222, - (byte) 157, - (byte) 121, - (byte) 5, - (byte) 164, - (byte) 238, - (byte) 31, - (byte) 190, - (byte) 115, - (byte) 93, - (byte) 59, - (byte) 103, - (byte) 36, - (byte) 83, - (byte) 161, - (byte) 156, - (byte) 46, - (byte) 253, - (byte) 67, - (byte) 87, - (byte) 200, - (byte) 39, - (byte) 250, - (byte) 245, - (byte) 242, - (byte) 228, - (byte) 72, - (byte) 18, - (byte) 222, - (byte) 11, - (byte) 88, - (byte) 207, - (byte) 218, - (byte) 231, - (byte) 13, - (byte) 226, - (byte) 224, - (byte) 22, - (byte) 196, - (byte) 21, - (byte) 242, - (byte) 12, - (byte) 89, - (byte) 71, - (byte) 219, - (byte) 182, - (byte) 85, - (byte) 145, - (byte) 204, - (byte) 146, - (byte) 40, - (byte) 204, - (byte) 51, - (byte) 21, - (byte) 153, - (byte) 227, - (byte) 44, - (byte) 15, - (byte) 28, - (byte) 255, - (byte) 39, - (byte) 205, - (byte) 216, - (byte) 240, - (byte) 190, - (byte) 93, - (byte) 219, - (byte) 103, - (byte) 42, - (byte) 41, - (byte) 182, - (byte) 76, - (byte) 222, - (byte) 17, - (byte) 23, - (byte) 125, - (byte) 31, - (byte) 18, - (byte) 229, - (byte) 28, - (byte) 47, - (byte) 214, - (byte) 25, - (byte) 100, - (byte) 84, - (byte) 106, - (byte) 72, - (byte) 48, - (byte) 10, - (byte) 222, - (byte) 232, - (byte) 235, - (byte) 73, - (byte) 109, - (byte) 163, - (byte) 51, - (byte) 152, - (byte) 133, - (byte) 235, - (byte) 87, - (byte) 70, - (byte) 2, - (byte) 108, - (byte) 91, - (byte) 101, - (byte) 200, - (byte) 55, - (byte) 24, - (byte) 156, - (byte) 233, - (byte) 73, - (byte) 39, - (byte) 66, - (byte) 97, - (byte) 140, - (byte) 252, - (byte) 227, - (byte) 230, - (byte) 237, - (byte) 135, - (byte) 241, - (byte) 245, - (byte) 205, - (byte) 70, - (byte) 0, - (byte) 219, - (byte) 188, - (byte) 107, - (byte) 136, - (byte) 178, - (byte) 58, - (byte) 1, - (byte) 29, - (byte) 44, - (byte) 213, - (byte) 225, - (byte) 147, - (byte) 190, - (byte) 96, - (byte) 192, - (byte) 108, - (byte) 228, - (byte) 15, - (byte) 203, - (byte) 18, - (byte) 3, - (byte) 222, - (byte) 180, - (byte) 68, - (byte) 101, - (byte) 229, - (byte) 223, - (byte) 203, - (byte) 243, - (byte) 164, - (byte) 92, - (byte) 165, - (byte) 220, - (byte) 159, - (byte) 174, - (byte) 121, - (byte) 112, - (byte) 167, - (byte) 240, - (byte) 40, - (byte) 59, - (byte) 3, - (byte) 230, - (byte) 52, - (byte) 149, - (byte) 148, - (byte) 218, - (byte) 142, - (byte) 212, - (byte) 109, - (byte) 176, - (byte) 71, - (byte) 179, - (byte) 172, - (byte) 77, - (byte) 1, - (byte) 193, - (byte) 70, - (byte) 147, - (byte) 149, - (byte) 23, - (byte) 144, - (byte) 148, - (byte) 239, - (byte) 195, - (byte) 186, - (byte) 86, - (byte) 30, - (byte) 34, - (byte) 143, - (byte) 156, - (byte) 207, - (byte) 63, - (byte) 55, - (byte) 117, - (byte) 255, - (byte) 222, - (byte) 222, - (byte) 219, - (byte) 145, - (byte) 224, - (byte) 191, - (byte) 210, - (byte) 109, - (byte) 86, - (byte) 153, - (byte) 21, - (byte) 32, - (byte) 226, - (byte) 10, - (byte) 60, - (byte) 63, - (byte) 106, - (byte) 236, - (byte) 93, - (byte) 96, - (byte) 30, - (byte) 163, - (byte) 106, - (byte) 238, - (byte) 147, - (byte) 133, - (byte) 132, - (byte) 107, - (byte) 152, - (byte) 214, - (byte) 221, - (byte) 185, - (byte) 202, - (byte) 21, - (byte) 252, - (byte) 51, - (byte) 130, - (byte) 59, - (byte) 166, - (byte) 202, - (byte) 127, - (byte) 170, - (byte) 58, - (byte) 193, - (byte) 215, - (byte) 125, - (byte) 22, - (byte) 58, - (byte) 135, - (byte) 47, - (byte) 88, - (byte) 142, - }; - SBPMessage sbp = new SBPMessage(0xf154, 0xff0f, payload); - MsgSolnMetaDepA msg = new MsgSolnMetaDepA(sbp); + byte[] payload = new byte[] {(byte)183,(byte)222,(byte)157,(byte)121,(byte)5,(byte)164,(byte)238,(byte)31,(byte)190,(byte)115,(byte)93,(byte)59,(byte)103,(byte)36,(byte)83,(byte)161,(byte)156,(byte)46,(byte)253,(byte)67,(byte)87,(byte)200,(byte)39,(byte)250,(byte)245,(byte)242,(byte)228,(byte)72,(byte)18,(byte)222,(byte)11,(byte)88,(byte)207,(byte)218,(byte)231,(byte)13,(byte)226,(byte)224,(byte)22,(byte)196,(byte)21,(byte)242,(byte)12,(byte)89,(byte)71,(byte)219,(byte)182,(byte)85,(byte)145,(byte)204,(byte)146,(byte)40,(byte)204,(byte)51,(byte)21,(byte)153,(byte)227,(byte)44,(byte)15,(byte)28,(byte)255,(byte)39,(byte)205,(byte)216,(byte)240,(byte)190,(byte)93,(byte)219,(byte)103,(byte)42,(byte)41,(byte)182,(byte)76,(byte)222,(byte)17,(byte)23,(byte)125,(byte)31,(byte)18,(byte)229,(byte)28,(byte)47,(byte)214,(byte)25,(byte)100,(byte)84,(byte)106,(byte)72,(byte)48,(byte)10,(byte)222,(byte)232,(byte)235,(byte)73,(byte)109,(byte)163,(byte)51,(byte)152,(byte)133,(byte)235,(byte)87,(byte)70,(byte)2,(byte)108,(byte)91,(byte)101,(byte)200,(byte)55,(byte)24,(byte)156,(byte)233,(byte)73,(byte)39,(byte)66,(byte)97,(byte)140,(byte)252,(byte)227,(byte)230,(byte)237,(byte)135,(byte)241,(byte)245,(byte)205,(byte)70,(byte)0,(byte)219,(byte)188,(byte)107,(byte)136,(byte)178,(byte)58,(byte)1,(byte)29,(byte)44,(byte)213,(byte)225,(byte)147,(byte)190,(byte)96,(byte)192,(byte)108,(byte)228,(byte)15,(byte)203,(byte)18,(byte)3,(byte)222,(byte)180,(byte)68,(byte)101,(byte)229,(byte)223,(byte)203,(byte)243,(byte)164,(byte)92,(byte)165,(byte)220,(byte)159,(byte)174,(byte)121,(byte)112,(byte)167,(byte)240,(byte)40,(byte)59,(byte)3,(byte)230,(byte)52,(byte)149,(byte)148,(byte)218,(byte)142,(byte)212,(byte)109,(byte)176,(byte)71,(byte)179,(byte)172,(byte)77,(byte)1,(byte)193,(byte)70,(byte)147,(byte)149,(byte)23,(byte)144,(byte)148,(byte)239,(byte)195,(byte)186,(byte)86,(byte)30,(byte)34,(byte)143,(byte)156,(byte)207,(byte)63,(byte)55,(byte)117,(byte)255,(byte)222,(byte)222,(byte)219,(byte)145,(byte)224,(byte)191,(byte)210,(byte)109,(byte)86,(byte)153,(byte)21,(byte)32,(byte)226,(byte)10,(byte)60,(byte)63,(byte)106,(byte)236,(byte)93,(byte)96,(byte)30,(byte)163,(byte)106,(byte)238,(byte)147,(byte)133,(byte)132,(byte)107,(byte)152,(byte)214,(byte)221,(byte)185,(byte)202,(byte)21,(byte)252,(byte)51,(byte)130,(byte)59,(byte)166,(byte)202,(byte)127,(byte)170,(byte)58,(byte)193,(byte)215,(byte)125,(byte)22,(byte)58,(byte)135,(byte)47,(byte)88,(byte)142, }; + SBPMessage sbp = new SBPMessage( 0xf154, 0xff0f, payload ); + MsgSolnMetaDepA msg = new MsgSolnMetaDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.age_corrections; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.age_corrections + "' != '" + 48671 + "'", - value.equals(BigInteger.valueOf(48671L))); + org.junit.Assert.assertTrue("'" + msg.age_corrections + "' != '" + 48671 + "'", value.equals(BigInteger.valueOf( 48671L ) ) ); } else { value = value.longValue(); expected = 48671L; @@ -304,9 +50,7 @@ public void test1() throws Throwable { } value = msg.alignment_status; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.alignment_status + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.alignment_status + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -314,9 +58,7 @@ public void test1() throws Throwable { } value = msg.hdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hdop + "' != '" + 31133 + "'", - value.equals(BigInteger.valueOf(31133L))); + org.junit.Assert.assertTrue("'" + msg.hdop + "' != '" + 31133 + "'", value.equals(BigInteger.valueOf( 31133L ) ) ); } else { value = value.longValue(); expected = 31133L; @@ -324,9 +66,7 @@ public void test1() throws Throwable { } value = msg.last_used_gnss_pos_tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.last_used_gnss_pos_tow + "' != '" + 610745181 + "'", - value.equals(BigInteger.valueOf(610745181L))); + org.junit.Assert.assertTrue("'" + msg.last_used_gnss_pos_tow + "' != '" + 610745181 + "'", value.equals(BigInteger.valueOf( 610745181L ) ) ); } else { value = value.longValue(); expected = 610745181L; @@ -334,9 +74,7 @@ public void test1() throws Throwable { } value = msg.last_used_gnss_vel_tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.last_used_gnss_vel_tow + "' != '" + 782016851 + "'", - value.equals(BigInteger.valueOf(782016851L))); + org.junit.Assert.assertTrue("'" + msg.last_used_gnss_vel_tow + "' != '" + 782016851 + "'", value.equals(BigInteger.valueOf( 782016851L ) ) ); } else { value = value.longValue(); expected = 782016851L; @@ -344,9 +82,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -354,9 +90,7 @@ public void test1() throws Throwable { } value = msg.pdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pdop + "' != '" + 57015 + "'", - value.equals(BigInteger.valueOf(57015L))); + org.junit.Assert.assertTrue("'" + msg.pdop + "' != '" + 57015 + "'", value.equals(BigInteger.valueOf( 57015L ) ) ); } else { value = value.longValue(); expected = 57015L; @@ -364,9 +98,7 @@ public void test1() throws Throwable { } value = msg.sol_in[0].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[0].flags + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[0].flags + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -374,9 +106,7 @@ public void test1() throws Throwable { } value = msg.sol_in[0].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[0].sensor_type + "' != '" + 253 + "'", - value.equals(BigInteger.valueOf(253L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[0].sensor_type + "' != '" + 253 + "'", value.equals(BigInteger.valueOf( 253L ) ) ); } else { value = value.longValue(); expected = 253L; @@ -384,9 +114,7 @@ public void test1() throws Throwable { } value = msg.sol_in[1].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[1].flags + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[1].flags + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -394,9 +122,7 @@ public void test1() throws Throwable { } value = msg.sol_in[1].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[1].sensor_type + "' != '" + 87 + "'", - value.equals(BigInteger.valueOf(87L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[1].sensor_type + "' != '" + 87 + "'", value.equals(BigInteger.valueOf( 87L ) ) ); } else { value = value.longValue(); expected = 87L; @@ -404,9 +130,7 @@ public void test1() throws Throwable { } value = msg.sol_in[2].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[2].flags + "' != '" + 250 + "'", - value.equals(BigInteger.valueOf(250L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[2].flags + "' != '" + 250 + "'", value.equals(BigInteger.valueOf( 250L ) ) ); } else { value = value.longValue(); expected = 250L; @@ -414,9 +138,7 @@ public void test1() throws Throwable { } value = msg.sol_in[2].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[2].sensor_type + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[2].sensor_type + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -424,9 +146,7 @@ public void test1() throws Throwable { } value = msg.sol_in[3].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[3].flags + "' != '" + 242 + "'", - value.equals(BigInteger.valueOf(242L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[3].flags + "' != '" + 242 + "'", value.equals(BigInteger.valueOf( 242L ) ) ); } else { value = value.longValue(); expected = 242L; @@ -434,9 +154,7 @@ public void test1() throws Throwable { } value = msg.sol_in[3].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[3].sensor_type + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[3].sensor_type + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -444,9 +162,7 @@ public void test1() throws Throwable { } value = msg.sol_in[4].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[4].flags + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[4].flags + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -454,9 +170,7 @@ public void test1() throws Throwable { } value = msg.sol_in[4].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[4].sensor_type + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[4].sensor_type + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -464,9 +178,7 @@ public void test1() throws Throwable { } value = msg.sol_in[5].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[5].flags + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[5].flags + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -474,9 +186,7 @@ public void test1() throws Throwable { } value = msg.sol_in[5].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[5].sensor_type + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[5].sensor_type + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -484,9 +194,7 @@ public void test1() throws Throwable { } value = msg.sol_in[6].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[6].flags + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[6].flags + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -494,9 +202,7 @@ public void test1() throws Throwable { } value = msg.sol_in[6].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[6].sensor_type + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[6].sensor_type + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -504,9 +210,7 @@ public void test1() throws Throwable { } value = msg.sol_in[7].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[7].flags + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[7].flags + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -514,9 +218,7 @@ public void test1() throws Throwable { } value = msg.sol_in[7].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[7].sensor_type + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[7].sensor_type + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -524,9 +226,7 @@ public void test1() throws Throwable { } value = msg.sol_in[8].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[8].flags + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[8].flags + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -534,9 +234,7 @@ public void test1() throws Throwable { } value = msg.sol_in[8].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[8].sensor_type + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[8].sensor_type + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -544,9 +242,7 @@ public void test1() throws Throwable { } value = msg.sol_in[9].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[9].flags + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[9].flags + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -554,9 +250,7 @@ public void test1() throws Throwable { } value = msg.sol_in[9].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[9].sensor_type + "' != '" + 226 + "'", - value.equals(BigInteger.valueOf(226L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[9].sensor_type + "' != '" + 226 + "'", value.equals(BigInteger.valueOf( 226L ) ) ); } else { value = value.longValue(); expected = 226L; @@ -564,9 +258,7 @@ public void test1() throws Throwable { } value = msg.sol_in[10].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[10].flags + "' != '" + 196 + "'", - value.equals(BigInteger.valueOf(196L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[10].flags + "' != '" + 196 + "'", value.equals(BigInteger.valueOf( 196L ) ) ); } else { value = value.longValue(); expected = 196L; @@ -574,9 +266,7 @@ public void test1() throws Throwable { } value = msg.sol_in[10].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[10].sensor_type + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[10].sensor_type + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -584,9 +274,7 @@ public void test1() throws Throwable { } value = msg.sol_in[11].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[11].flags + "' != '" + 242 + "'", - value.equals(BigInteger.valueOf(242L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[11].flags + "' != '" + 242 + "'", value.equals(BigInteger.valueOf( 242L ) ) ); } else { value = value.longValue(); expected = 242L; @@ -594,9 +282,7 @@ public void test1() throws Throwable { } value = msg.sol_in[11].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[11].sensor_type + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[11].sensor_type + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -604,9 +290,7 @@ public void test1() throws Throwable { } value = msg.sol_in[12].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[12].flags + "' != '" + 89 + "'", - value.equals(BigInteger.valueOf(89L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[12].flags + "' != '" + 89 + "'", value.equals(BigInteger.valueOf( 89L ) ) ); } else { value = value.longValue(); expected = 89L; @@ -614,9 +298,7 @@ public void test1() throws Throwable { } value = msg.sol_in[12].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[12].sensor_type + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[12].sensor_type + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -624,9 +306,7 @@ public void test1() throws Throwable { } value = msg.sol_in[13].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[13].flags + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[13].flags + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -634,9 +314,7 @@ public void test1() throws Throwable { } value = msg.sol_in[13].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[13].sensor_type + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[13].sensor_type + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -644,9 +322,7 @@ public void test1() throws Throwable { } value = msg.sol_in[14].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[14].flags + "' != '" + 85 + "'", - value.equals(BigInteger.valueOf(85L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[14].flags + "' != '" + 85 + "'", value.equals(BigInteger.valueOf( 85L ) ) ); } else { value = value.longValue(); expected = 85L; @@ -654,9 +330,7 @@ public void test1() throws Throwable { } value = msg.sol_in[14].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[14].sensor_type + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[14].sensor_type + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -664,9 +338,7 @@ public void test1() throws Throwable { } value = msg.sol_in[15].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[15].flags + "' != '" + 204 + "'", - value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[15].flags + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -674,9 +346,7 @@ public void test1() throws Throwable { } value = msg.sol_in[15].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[15].sensor_type + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[15].sensor_type + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -684,9 +354,7 @@ public void test1() throws Throwable { } value = msg.sol_in[16].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[16].flags + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[16].flags + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -694,9 +362,7 @@ public void test1() throws Throwable { } value = msg.sol_in[16].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[16].sensor_type + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[16].sensor_type + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -704,9 +370,7 @@ public void test1() throws Throwable { } value = msg.sol_in[17].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[17].flags + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[17].flags + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -714,9 +378,7 @@ public void test1() throws Throwable { } value = msg.sol_in[17].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[17].sensor_type + "' != '" + 204 + "'", - value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[17].sensor_type + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -724,9 +386,7 @@ public void test1() throws Throwable { } value = msg.sol_in[18].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[18].flags + "' != '" + 153 + "'", - value.equals(BigInteger.valueOf(153L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[18].flags + "' != '" + 153 + "'", value.equals(BigInteger.valueOf( 153L ) ) ); } else { value = value.longValue(); expected = 153L; @@ -734,9 +394,7 @@ public void test1() throws Throwable { } value = msg.sol_in[18].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[18].sensor_type + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[18].sensor_type + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -744,9 +402,7 @@ public void test1() throws Throwable { } value = msg.sol_in[19].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[19].flags + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[19].flags + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -754,9 +410,7 @@ public void test1() throws Throwable { } value = msg.sol_in[19].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[19].sensor_type + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[19].sensor_type + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -764,9 +418,7 @@ public void test1() throws Throwable { } value = msg.sol_in[20].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[20].flags + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[20].flags + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -774,9 +426,7 @@ public void test1() throws Throwable { } value = msg.sol_in[20].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[20].sensor_type + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[20].sensor_type + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -784,9 +434,7 @@ public void test1() throws Throwable { } value = msg.sol_in[21].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[21].flags + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[21].flags + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -794,9 +442,7 @@ public void test1() throws Throwable { } value = msg.sol_in[21].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[21].sensor_type + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[21].sensor_type + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -804,9 +450,7 @@ public void test1() throws Throwable { } value = msg.sol_in[22].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[22].flags + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[22].flags + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -814,9 +458,7 @@ public void test1() throws Throwable { } value = msg.sol_in[22].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[22].sensor_type + "' != '" + 205 + "'", - value.equals(BigInteger.valueOf(205L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[22].sensor_type + "' != '" + 205 + "'", value.equals(BigInteger.valueOf( 205L ) ) ); } else { value = value.longValue(); expected = 205L; @@ -824,9 +466,7 @@ public void test1() throws Throwable { } value = msg.sol_in[23].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[23].flags + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[23].flags + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -834,9 +474,7 @@ public void test1() throws Throwable { } value = msg.sol_in[23].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[23].sensor_type + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[23].sensor_type + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -844,9 +482,7 @@ public void test1() throws Throwable { } value = msg.sol_in[24].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[24].flags + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[24].flags + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -854,9 +490,7 @@ public void test1() throws Throwable { } value = msg.sol_in[24].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[24].sensor_type + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[24].sensor_type + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -864,9 +498,7 @@ public void test1() throws Throwable { } value = msg.sol_in[25].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[25].flags + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[25].flags + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -874,9 +506,7 @@ public void test1() throws Throwable { } value = msg.sol_in[25].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[25].sensor_type + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[25].sensor_type + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -884,9 +514,7 @@ public void test1() throws Throwable { } value = msg.sol_in[26].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[26].flags + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[26].flags + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -894,9 +522,7 @@ public void test1() throws Throwable { } value = msg.sol_in[26].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[26].sensor_type + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[26].sensor_type + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -904,9 +530,7 @@ public void test1() throws Throwable { } value = msg.sol_in[27].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[27].flags + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[27].flags + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -914,9 +538,7 @@ public void test1() throws Throwable { } value = msg.sol_in[27].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[27].sensor_type + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[27].sensor_type + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -924,9 +546,7 @@ public void test1() throws Throwable { } value = msg.sol_in[28].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[28].flags + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[28].flags + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -934,9 +554,7 @@ public void test1() throws Throwable { } value = msg.sol_in[28].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[28].sensor_type + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[28].sensor_type + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -944,9 +562,7 @@ public void test1() throws Throwable { } value = msg.sol_in[29].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[29].flags + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[29].flags + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -954,9 +570,7 @@ public void test1() throws Throwable { } value = msg.sol_in[29].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[29].sensor_type + "' != '" + 125 + "'", - value.equals(BigInteger.valueOf(125L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[29].sensor_type + "' != '" + 125 + "'", value.equals(BigInteger.valueOf( 125L ) ) ); } else { value = value.longValue(); expected = 125L; @@ -964,9 +578,7 @@ public void test1() throws Throwable { } value = msg.sol_in[30].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[30].flags + "' != '" + 229 + "'", - value.equals(BigInteger.valueOf(229L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[30].flags + "' != '" + 229 + "'", value.equals(BigInteger.valueOf( 229L ) ) ); } else { value = value.longValue(); expected = 229L; @@ -974,9 +586,7 @@ public void test1() throws Throwable { } value = msg.sol_in[30].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[30].sensor_type + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[30].sensor_type + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -984,9 +594,7 @@ public void test1() throws Throwable { } value = msg.sol_in[31].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[31].flags + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[31].flags + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -994,9 +602,7 @@ public void test1() throws Throwable { } value = msg.sol_in[31].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[31].sensor_type + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[31].sensor_type + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -1004,9 +610,7 @@ public void test1() throws Throwable { } value = msg.sol_in[32].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[32].flags + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[32].flags + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -1014,9 +618,7 @@ public void test1() throws Throwable { } value = msg.sol_in[32].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[32].sensor_type + "' != '" + 214 + "'", - value.equals(BigInteger.valueOf(214L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[32].sensor_type + "' != '" + 214 + "'", value.equals(BigInteger.valueOf( 214L ) ) ); } else { value = value.longValue(); expected = 214L; @@ -1024,9 +626,7 @@ public void test1() throws Throwable { } value = msg.sol_in[33].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[33].flags + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[33].flags + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -1034,9 +634,7 @@ public void test1() throws Throwable { } value = msg.sol_in[33].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[33].sensor_type + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[33].sensor_type + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -1044,9 +642,7 @@ public void test1() throws Throwable { } value = msg.sol_in[34].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[34].flags + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[34].flags + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -1054,9 +650,7 @@ public void test1() throws Throwable { } value = msg.sol_in[34].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[34].sensor_type + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[34].sensor_type + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -1064,9 +658,7 @@ public void test1() throws Throwable { } value = msg.sol_in[35].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[35].flags + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[35].flags + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -1074,9 +666,7 @@ public void test1() throws Throwable { } value = msg.sol_in[35].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[35].sensor_type + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[35].sensor_type + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -1084,9 +674,7 @@ public void test1() throws Throwable { } value = msg.sol_in[36].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[36].flags + "' != '" + 232 + "'", - value.equals(BigInteger.valueOf(232L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[36].flags + "' != '" + 232 + "'", value.equals(BigInteger.valueOf( 232L ) ) ); } else { value = value.longValue(); expected = 232L; @@ -1094,9 +682,7 @@ public void test1() throws Throwable { } value = msg.sol_in[36].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[36].sensor_type + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[36].sensor_type + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -1104,9 +690,7 @@ public void test1() throws Throwable { } value = msg.sol_in[37].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[37].flags + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[37].flags + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -1114,9 +698,7 @@ public void test1() throws Throwable { } value = msg.sol_in[37].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[37].sensor_type + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[37].sensor_type + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -1124,9 +706,7 @@ public void test1() throws Throwable { } value = msg.sol_in[38].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[38].flags + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[38].flags + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -1134,9 +714,7 @@ public void test1() throws Throwable { } value = msg.sol_in[38].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[38].sensor_type + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[38].sensor_type + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -1144,9 +722,7 @@ public void test1() throws Throwable { } value = msg.sol_in[39].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[39].flags + "' != '" + 152 + "'", - value.equals(BigInteger.valueOf(152L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[39].flags + "' != '" + 152 + "'", value.equals(BigInteger.valueOf( 152L ) ) ); } else { value = value.longValue(); expected = 152L; @@ -1154,9 +730,7 @@ public void test1() throws Throwable { } value = msg.sol_in[39].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[39].sensor_type + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[39].sensor_type + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -1164,9 +738,7 @@ public void test1() throws Throwable { } value = msg.sol_in[40].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[40].flags + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[40].flags + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -1174,9 +746,7 @@ public void test1() throws Throwable { } value = msg.sol_in[40].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[40].sensor_type + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[40].sensor_type + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -1184,9 +754,7 @@ public void test1() throws Throwable { } value = msg.sol_in[41].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[41].flags + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[41].flags + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -1194,9 +762,7 @@ public void test1() throws Throwable { } value = msg.sol_in[41].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[41].sensor_type + "' != '" + 87 + "'", - value.equals(BigInteger.valueOf(87L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[41].sensor_type + "' != '" + 87 + "'", value.equals(BigInteger.valueOf( 87L ) ) ); } else { value = value.longValue(); expected = 87L; @@ -1204,9 +770,7 @@ public void test1() throws Throwable { } value = msg.sol_in[42].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[42].flags + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[42].flags + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -1214,9 +778,7 @@ public void test1() throws Throwable { } value = msg.sol_in[42].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[42].sensor_type + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[42].sensor_type + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1224,9 +786,7 @@ public void test1() throws Throwable { } value = msg.sol_in[43].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[43].flags + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[43].flags + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -1234,9 +794,7 @@ public void test1() throws Throwable { } value = msg.sol_in[43].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[43].sensor_type + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[43].sensor_type + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -1244,9 +802,7 @@ public void test1() throws Throwable { } value = msg.sol_in[44].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[44].flags + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[44].flags + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -1254,9 +810,7 @@ public void test1() throws Throwable { } value = msg.sol_in[44].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[44].sensor_type + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[44].sensor_type + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -1264,9 +818,7 @@ public void test1() throws Throwable { } value = msg.sol_in[45].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[45].flags + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[45].flags + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -1274,9 +826,7 @@ public void test1() throws Throwable { } value = msg.sol_in[45].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[45].sensor_type + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[45].sensor_type + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -1284,9 +834,7 @@ public void test1() throws Throwable { } value = msg.sol_in[46].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[46].flags + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[46].flags + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -1294,9 +842,7 @@ public void test1() throws Throwable { } value = msg.sol_in[46].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[46].sensor_type + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[46].sensor_type + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -1304,9 +850,7 @@ public void test1() throws Throwable { } value = msg.sol_in[47].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[47].flags + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[47].flags + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -1314,9 +858,7 @@ public void test1() throws Throwable { } value = msg.sol_in[47].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[47].sensor_type + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[47].sensor_type + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -1324,9 +866,7 @@ public void test1() throws Throwable { } value = msg.sol_in[48].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[48].flags + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[48].flags + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -1334,9 +874,7 @@ public void test1() throws Throwable { } value = msg.sol_in[48].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[48].sensor_type + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[48].sensor_type + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -1344,9 +882,7 @@ public void test1() throws Throwable { } value = msg.sol_in[49].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[49].flags + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[49].flags + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1354,9 +890,7 @@ public void test1() throws Throwable { } value = msg.sol_in[49].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[49].sensor_type + "' != '" + 252 + "'", - value.equals(BigInteger.valueOf(252L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[49].sensor_type + "' != '" + 252 + "'", value.equals(BigInteger.valueOf( 252L ) ) ); } else { value = value.longValue(); expected = 252L; @@ -1364,9 +898,7 @@ public void test1() throws Throwable { } value = msg.sol_in[50].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[50].flags + "' != '" + 237 + "'", - value.equals(BigInteger.valueOf(237L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[50].flags + "' != '" + 237 + "'", value.equals(BigInteger.valueOf( 237L ) ) ); } else { value = value.longValue(); expected = 237L; @@ -1374,9 +906,7 @@ public void test1() throws Throwable { } value = msg.sol_in[50].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[50].sensor_type + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[50].sensor_type + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1384,9 +914,7 @@ public void test1() throws Throwable { } value = msg.sol_in[51].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[51].flags + "' != '" + 241 + "'", - value.equals(BigInteger.valueOf(241L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[51].flags + "' != '" + 241 + "'", value.equals(BigInteger.valueOf( 241L ) ) ); } else { value = value.longValue(); expected = 241L; @@ -1394,9 +922,7 @@ public void test1() throws Throwable { } value = msg.sol_in[51].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[51].sensor_type + "' != '" + 135 + "'", - value.equals(BigInteger.valueOf(135L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[51].sensor_type + "' != '" + 135 + "'", value.equals(BigInteger.valueOf( 135L ) ) ); } else { value = value.longValue(); expected = 135L; @@ -1404,9 +930,7 @@ public void test1() throws Throwable { } value = msg.sol_in[52].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[52].flags + "' != '" + 205 + "'", - value.equals(BigInteger.valueOf(205L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[52].flags + "' != '" + 205 + "'", value.equals(BigInteger.valueOf( 205L ) ) ); } else { value = value.longValue(); expected = 205L; @@ -1414,9 +938,7 @@ public void test1() throws Throwable { } value = msg.sol_in[52].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[52].sensor_type + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[52].sensor_type + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -1424,9 +946,7 @@ public void test1() throws Throwable { } value = msg.sol_in[53].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[53].flags + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[53].flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1434,9 +954,7 @@ public void test1() throws Throwable { } value = msg.sol_in[53].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[53].sensor_type + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[53].sensor_type + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -1444,9 +962,7 @@ public void test1() throws Throwable { } value = msg.sol_in[54].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[54].flags + "' != '" + 188 + "'", - value.equals(BigInteger.valueOf(188L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[54].flags + "' != '" + 188 + "'", value.equals(BigInteger.valueOf( 188L ) ) ); } else { value = value.longValue(); expected = 188L; @@ -1454,9 +970,7 @@ public void test1() throws Throwable { } value = msg.sol_in[54].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[54].sensor_type + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[54].sensor_type + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -1464,9 +978,7 @@ public void test1() throws Throwable { } value = msg.sol_in[55].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[55].flags + "' != '" + 136 + "'", - value.equals(BigInteger.valueOf(136L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[55].flags + "' != '" + 136 + "'", value.equals(BigInteger.valueOf( 136L ) ) ); } else { value = value.longValue(); expected = 136L; @@ -1474,9 +986,7 @@ public void test1() throws Throwable { } value = msg.sol_in[55].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[55].sensor_type + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[55].sensor_type + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -1484,9 +994,7 @@ public void test1() throws Throwable { } value = msg.sol_in[56].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[56].flags + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[56].flags + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -1494,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.sol_in[56].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[56].sensor_type + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[56].sensor_type + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -1504,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.sol_in[57].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[57].flags + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[57].flags + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -1514,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.sol_in[57].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[57].sensor_type + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[57].sensor_type + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1524,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.sol_in[58].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[58].flags + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[58].flags + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -1534,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.sol_in[58].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[58].sensor_type + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[58].sensor_type + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -1544,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.sol_in[59].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[59].flags + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[59].flags + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -1554,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.sol_in[59].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[59].sensor_type + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[59].sensor_type + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -1564,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.sol_in[60].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[60].flags + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[60].flags + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -1574,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.sol_in[60].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[60].sensor_type + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[60].sensor_type + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -1584,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.sol_in[61].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[61].flags + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[61].flags + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -1594,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.sol_in[61].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[61].sensor_type + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[61].sensor_type + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -1604,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.sol_in[62].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[62].flags + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[62].flags + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -1614,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.sol_in[62].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[62].sensor_type + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[62].sensor_type + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -1624,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.sol_in[63].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[63].flags + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[63].flags + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -1634,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.sol_in[63].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[63].sensor_type + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[63].sensor_type + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -1644,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.sol_in[64].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[64].flags + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[64].flags + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -1654,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.sol_in[64].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[64].sensor_type + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[64].sensor_type + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1664,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.sol_in[65].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[65].flags + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[65].flags + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -1674,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.sol_in[65].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[65].sensor_type + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[65].sensor_type + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -1684,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.sol_in[66].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[66].flags + "' != '" + 229 + "'", - value.equals(BigInteger.valueOf(229L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[66].flags + "' != '" + 229 + "'", value.equals(BigInteger.valueOf( 229L ) ) ); } else { value = value.longValue(); expected = 229L; @@ -1694,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.sol_in[66].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[66].sensor_type + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[66].sensor_type + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -1704,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.sol_in[67].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[67].flags + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[67].flags + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -1714,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.sol_in[67].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[67].sensor_type + "' != '" + 223 + "'", - value.equals(BigInteger.valueOf(223L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[67].sensor_type + "' != '" + 223 + "'", value.equals(BigInteger.valueOf( 223L ) ) ); } else { value = value.longValue(); expected = 223L; @@ -1724,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.sol_in[68].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[68].flags + "' != '" + 164 + "'", - value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[68].flags + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -1734,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.sol_in[68].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[68].sensor_type + "' != '" + 243 + "'", - value.equals(BigInteger.valueOf(243L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[68].sensor_type + "' != '" + 243 + "'", value.equals(BigInteger.valueOf( 243L ) ) ); } else { value = value.longValue(); expected = 243L; @@ -1744,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.sol_in[69].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[69].flags + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[69].flags + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -1754,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.sol_in[69].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[69].sensor_type + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[69].sensor_type + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -1764,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.sol_in[70].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[70].flags + "' != '" + 159 + "'", - value.equals(BigInteger.valueOf(159L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[70].flags + "' != '" + 159 + "'", value.equals(BigInteger.valueOf( 159L ) ) ); } else { value = value.longValue(); expected = 159L; @@ -1774,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.sol_in[70].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[70].sensor_type + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[70].sensor_type + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -1784,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.sol_in[71].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[71].flags + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[71].flags + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -1794,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.sol_in[71].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[71].sensor_type + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[71].sensor_type + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -1804,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.sol_in[72].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[72].flags + "' != '" + 167 + "'", - value.equals(BigInteger.valueOf(167L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[72].flags + "' != '" + 167 + "'", value.equals(BigInteger.valueOf( 167L ) ) ); } else { value = value.longValue(); expected = 167L; @@ -1814,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.sol_in[72].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[72].sensor_type + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[72].sensor_type + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -1824,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.sol_in[73].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[73].flags + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[73].flags + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -1834,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.sol_in[73].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[73].sensor_type + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[73].sensor_type + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -1844,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.sol_in[74].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[74].flags + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[74].flags + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1854,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.sol_in[74].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[74].sensor_type + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[74].sensor_type + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -1864,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.sol_in[75].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[75].flags + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[75].flags + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -1874,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.sol_in[75].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[75].sensor_type + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[75].sensor_type + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1884,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.sol_in[76].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[76].flags + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[76].flags + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -1894,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.sol_in[76].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[76].sensor_type + "' != '" + 149 + "'", - value.equals(BigInteger.valueOf(149L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[76].sensor_type + "' != '" + 149 + "'", value.equals(BigInteger.valueOf( 149L ) ) ); } else { value = value.longValue(); expected = 149L; @@ -1904,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.sol_in[77].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[77].flags + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[77].flags + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -1914,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.sol_in[77].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[77].sensor_type + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[77].sensor_type + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -1924,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.sol_in[78].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[78].flags + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[78].flags + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -1934,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.sol_in[78].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[78].sensor_type + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[78].sensor_type + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -1944,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.sol_in[79].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[79].flags + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[79].flags + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -1954,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.sol_in[79].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[79].sensor_type + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[79].sensor_type + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -1964,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.sol_in[80].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[80].flags + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[80].flags + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -1974,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.sol_in[80].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[80].sensor_type + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[80].sensor_type + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -1984,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.sol_in[81].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[81].flags + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[81].flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1994,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.sol_in[81].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[81].sensor_type + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[81].sensor_type + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -2004,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.sol_in[82].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[82].flags + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[82].flags + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -2014,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.sol_in[82].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[82].sensor_type + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[82].sensor_type + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -2024,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.sol_in[83].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[83].flags + "' != '" + 149 + "'", - value.equals(BigInteger.valueOf(149L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[83].flags + "' != '" + 149 + "'", value.equals(BigInteger.valueOf( 149L ) ) ); } else { value = value.longValue(); expected = 149L; @@ -2034,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.sol_in[83].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[83].sensor_type + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[83].sensor_type + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -2044,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.sol_in[84].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[84].flags + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[84].flags + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -2054,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.sol_in[84].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[84].sensor_type + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[84].sensor_type + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -2064,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.sol_in[85].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[85].flags + "' != '" + 239 + "'", - value.equals(BigInteger.valueOf(239L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[85].flags + "' != '" + 239 + "'", value.equals(BigInteger.valueOf( 239L ) ) ); } else { value = value.longValue(); expected = 239L; @@ -2074,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.sol_in[85].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[85].sensor_type + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[85].sensor_type + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -2084,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.sol_in[86].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[86].flags + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[86].flags + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -2094,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.sol_in[86].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[86].sensor_type + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[86].sensor_type + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -2104,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.sol_in[87].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[87].flags + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[87].flags + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -2114,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.sol_in[87].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[87].sensor_type + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[87].sensor_type + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -2124,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.sol_in[88].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[88].flags + "' != '" + 143 + "'", - value.equals(BigInteger.valueOf(143L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[88].flags + "' != '" + 143 + "'", value.equals(BigInteger.valueOf( 143L ) ) ); } else { value = value.longValue(); expected = 143L; @@ -2134,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.sol_in[88].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[88].sensor_type + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[88].sensor_type + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -2144,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.sol_in[89].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[89].flags + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[89].flags + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -2154,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.sol_in[89].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[89].sensor_type + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[89].sensor_type + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -2164,9 +1538,7 @@ public void test1() throws Throwable { } value = msg.sol_in[90].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[90].flags + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[90].flags + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -2174,9 +1546,7 @@ public void test1() throws Throwable { } value = msg.sol_in[90].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[90].sensor_type + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[90].sensor_type + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -2184,9 +1554,7 @@ public void test1() throws Throwable { } value = msg.sol_in[91].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[91].flags + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[91].flags + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -2194,9 +1562,7 @@ public void test1() throws Throwable { } value = msg.sol_in[91].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[91].sensor_type + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[91].sensor_type + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -2204,9 +1570,7 @@ public void test1() throws Throwable { } value = msg.sol_in[92].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[92].flags + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[92].flags + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -2214,9 +1578,7 @@ public void test1() throws Throwable { } value = msg.sol_in[92].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[92].sensor_type + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[92].sensor_type + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -2224,9 +1586,7 @@ public void test1() throws Throwable { } value = msg.sol_in[93].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[93].flags + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[93].flags + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -2234,9 +1594,7 @@ public void test1() throws Throwable { } value = msg.sol_in[93].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[93].sensor_type + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[93].sensor_type + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -2244,9 +1602,7 @@ public void test1() throws Throwable { } value = msg.sol_in[94].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[94].flags + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[94].flags + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -2254,9 +1610,7 @@ public void test1() throws Throwable { } value = msg.sol_in[94].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[94].sensor_type + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[94].sensor_type + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -2264,9 +1618,7 @@ public void test1() throws Throwable { } value = msg.sol_in[95].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[95].flags + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[95].flags + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -2274,9 +1626,7 @@ public void test1() throws Throwable { } value = msg.sol_in[95].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[95].sensor_type + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[95].sensor_type + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -2284,9 +1634,7 @@ public void test1() throws Throwable { } value = msg.sol_in[96].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[96].flags + "' != '" + 153 + "'", - value.equals(BigInteger.valueOf(153L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[96].flags + "' != '" + 153 + "'", value.equals(BigInteger.valueOf( 153L ) ) ); } else { value = value.longValue(); expected = 153L; @@ -2294,9 +1642,7 @@ public void test1() throws Throwable { } value = msg.sol_in[96].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[96].sensor_type + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[96].sensor_type + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -2304,9 +1650,7 @@ public void test1() throws Throwable { } value = msg.sol_in[97].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[97].flags + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[97].flags + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -2314,9 +1658,7 @@ public void test1() throws Throwable { } value = msg.sol_in[97].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[97].sensor_type + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[97].sensor_type + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -2324,9 +1666,7 @@ public void test1() throws Throwable { } value = msg.sol_in[98].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[98].flags + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[98].flags + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -2334,9 +1674,7 @@ public void test1() throws Throwable { } value = msg.sol_in[98].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[98].sensor_type + "' != '" + 226 + "'", - value.equals(BigInteger.valueOf(226L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[98].sensor_type + "' != '" + 226 + "'", value.equals(BigInteger.valueOf( 226L ) ) ); } else { value = value.longValue(); expected = 226L; @@ -2344,9 +1682,7 @@ public void test1() throws Throwable { } value = msg.sol_in[99].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[99].flags + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[99].flags + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -2354,9 +1690,7 @@ public void test1() throws Throwable { } value = msg.sol_in[99].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[99].sensor_type + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[99].sensor_type + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -2364,9 +1698,7 @@ public void test1() throws Throwable { } value = msg.sol_in[100].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[100].flags + "' != '" + 236 + "'", - value.equals(BigInteger.valueOf(236L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[100].flags + "' != '" + 236 + "'", value.equals(BigInteger.valueOf( 236L ) ) ); } else { value = value.longValue(); expected = 236L; @@ -2374,9 +1706,7 @@ public void test1() throws Throwable { } value = msg.sol_in[100].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[100].sensor_type + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[100].sensor_type + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -2384,9 +1714,7 @@ public void test1() throws Throwable { } value = msg.sol_in[101].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[101].flags + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[101].flags + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -2394,9 +1722,7 @@ public void test1() throws Throwable { } value = msg.sol_in[101].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[101].sensor_type + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[101].sensor_type + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -2404,9 +1730,7 @@ public void test1() throws Throwable { } value = msg.sol_in[102].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[102].flags + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[102].flags + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -2414,9 +1738,7 @@ public void test1() throws Throwable { } value = msg.sol_in[102].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[102].sensor_type + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[102].sensor_type + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -2424,9 +1746,7 @@ public void test1() throws Throwable { } value = msg.sol_in[103].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[103].flags + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[103].flags + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -2434,9 +1754,7 @@ public void test1() throws Throwable { } value = msg.sol_in[103].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[103].sensor_type + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[103].sensor_type + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -2444,9 +1762,7 @@ public void test1() throws Throwable { } value = msg.sol_in[104].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[104].flags + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[104].flags + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -2454,9 +1770,7 @@ public void test1() throws Throwable { } value = msg.sol_in[104].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[104].sensor_type + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[104].sensor_type + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -2464,9 +1778,7 @@ public void test1() throws Throwable { } value = msg.sol_in[105].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[105].flags + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[105].flags + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -2474,9 +1786,7 @@ public void test1() throws Throwable { } value = msg.sol_in[105].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[105].sensor_type + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[105].sensor_type + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -2484,9 +1794,7 @@ public void test1() throws Throwable { } value = msg.sol_in[106].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[106].flags + "' != '" + 214 + "'", - value.equals(BigInteger.valueOf(214L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[106].flags + "' != '" + 214 + "'", value.equals(BigInteger.valueOf( 214L ) ) ); } else { value = value.longValue(); expected = 214L; @@ -2494,9 +1802,7 @@ public void test1() throws Throwable { } value = msg.sol_in[106].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[106].sensor_type + "' != '" + 152 + "'", - value.equals(BigInteger.valueOf(152L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[106].sensor_type + "' != '" + 152 + "'", value.equals(BigInteger.valueOf( 152L ) ) ); } else { value = value.longValue(); expected = 152L; @@ -2504,9 +1810,7 @@ public void test1() throws Throwable { } value = msg.sol_in[107].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[107].flags + "' != '" + 185 + "'", - value.equals(BigInteger.valueOf(185L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[107].flags + "' != '" + 185 + "'", value.equals(BigInteger.valueOf( 185L ) ) ); } else { value = value.longValue(); expected = 185L; @@ -2514,9 +1818,7 @@ public void test1() throws Throwable { } value = msg.sol_in[107].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[107].sensor_type + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[107].sensor_type + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -2524,9 +1826,7 @@ public void test1() throws Throwable { } value = msg.sol_in[108].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[108].flags + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[108].flags + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -2534,9 +1834,7 @@ public void test1() throws Throwable { } value = msg.sol_in[108].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[108].sensor_type + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[108].sensor_type + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -2544,9 +1842,7 @@ public void test1() throws Throwable { } value = msg.sol_in[109].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[109].flags + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[109].flags + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -2554,9 +1850,7 @@ public void test1() throws Throwable { } value = msg.sol_in[109].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[109].sensor_type + "' != '" + 252 + "'", - value.equals(BigInteger.valueOf(252L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[109].sensor_type + "' != '" + 252 + "'", value.equals(BigInteger.valueOf( 252L ) ) ); } else { value = value.longValue(); expected = 252L; @@ -2564,9 +1858,7 @@ public void test1() throws Throwable { } value = msg.sol_in[110].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[110].flags + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[110].flags + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -2574,9 +1866,7 @@ public void test1() throws Throwable { } value = msg.sol_in[110].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[110].sensor_type + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[110].sensor_type + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -2584,9 +1874,7 @@ public void test1() throws Throwable { } value = msg.sol_in[111].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[111].flags + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[111].flags + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -2594,9 +1882,7 @@ public void test1() throws Throwable { } value = msg.sol_in[111].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[111].sensor_type + "' != '" + 166 + "'", - value.equals(BigInteger.valueOf(166L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[111].sensor_type + "' != '" + 166 + "'", value.equals(BigInteger.valueOf( 166L ) ) ); } else { value = value.longValue(); expected = 166L; @@ -2604,9 +1890,7 @@ public void test1() throws Throwable { } value = msg.sol_in[112].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[112].flags + "' != '" + 170 + "'", - value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[112].flags + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -2614,9 +1898,7 @@ public void test1() throws Throwable { } value = msg.sol_in[112].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[112].sensor_type + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[112].sensor_type + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -2624,9 +1906,7 @@ public void test1() throws Throwable { } value = msg.sol_in[113].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[113].flags + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[113].flags + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -2634,9 +1914,7 @@ public void test1() throws Throwable { } value = msg.sol_in[113].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[113].sensor_type + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[113].sensor_type + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -2644,9 +1922,7 @@ public void test1() throws Throwable { } value = msg.sol_in[114].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[114].flags + "' != '" + 125 + "'", - value.equals(BigInteger.valueOf(125L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[114].flags + "' != '" + 125 + "'", value.equals(BigInteger.valueOf( 125L ) ) ); } else { value = value.longValue(); expected = 125L; @@ -2654,9 +1930,7 @@ public void test1() throws Throwable { } value = msg.sol_in[114].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[114].sensor_type + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[114].sensor_type + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -2664,9 +1938,7 @@ public void test1() throws Throwable { } value = msg.sol_in[115].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[115].flags + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[115].flags + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -2674,9 +1946,7 @@ public void test1() throws Throwable { } value = msg.sol_in[115].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[115].sensor_type + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[115].sensor_type + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -2684,9 +1954,7 @@ public void test1() throws Throwable { } value = msg.sol_in[116].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[116].flags + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[116].flags + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -2694,9 +1962,7 @@ public void test1() throws Throwable { } value = msg.sol_in[116].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[116].sensor_type + "' != '" + 135 + "'", - value.equals(BigInteger.valueOf(135L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[116].sensor_type + "' != '" + 135 + "'", value.equals(BigInteger.valueOf( 135L ) ) ); } else { value = value.longValue(); expected = 135L; @@ -2704,9 +1970,7 @@ public void test1() throws Throwable { } value = msg.sol_in[117].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[117].flags + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[117].flags + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -2714,9 +1978,7 @@ public void test1() throws Throwable { } value = msg.sol_in[117].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[117].sensor_type + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[117].sensor_type + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -2724,9 +1986,7 @@ public void test1() throws Throwable { } value = msg.vdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vdop + "' != '" + 41989 + "'", - value.equals(BigInteger.valueOf(41989L))); + org.junit.Assert.assertTrue("'" + msg.vdop + "' != '" + 41989 + "'", value.equals(BigInteger.valueOf( 41989L ) ) ); } else { value = value.longValue(); expected = 41989L; diff --git a/java/test/auto_check_sbp_solution_meta_MsgSolnMetaTest.java b/java/test/auto_check_sbp_solution_meta_MsgSolnMetaTest.java index 0a9149c9c..bfe2b934c 100644 --- a/java/test/auto_check_sbp_solution_meta_MsgSolnMetaTest.java +++ b/java/test/auto_check_sbp_solution_meta_MsgSolnMetaTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/soln_meta/test_MsgSolnMeta.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/soln_meta/test_MsgSolnMeta.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.solution_meta.MsgSolnMeta; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_solution_meta_MsgSolnMetaTest { @@ -29,273 +34,15 @@ public class auto_check_sbp_solution_meta_MsgSolnMetaTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_solution_meta_MsgSolnMetaTest.test1"); - byte[] payload = - new byte[] { - (byte) 48, - (byte) 208, - (byte) 65, - (byte) 216, - (byte) 122, - (byte) 45, - (byte) 196, - (byte) 160, - (byte) 144, - (byte) 228, - (byte) 8, - (byte) 83, - (byte) 89, - (byte) 87, - (byte) 3, - (byte) 213, - (byte) 95, - (byte) 109, - (byte) 86, - (byte) 131, - (byte) 71, - (byte) 70, - (byte) 84, - (byte) 73, - (byte) 131, - (byte) 26, - (byte) 82, - (byte) 247, - (byte) 140, - (byte) 97, - (byte) 115, - (byte) 110, - (byte) 118, - (byte) 253, - (byte) 2, - (byte) 122, - (byte) 186, - (byte) 148, - (byte) 122, - (byte) 148, - (byte) 180, - (byte) 231, - (byte) 68, - (byte) 46, - (byte) 190, - (byte) 102, - (byte) 243, - (byte) 48, - (byte) 192, - (byte) 15, - (byte) 208, - (byte) 89, - (byte) 56, - (byte) 10, - (byte) 245, - (byte) 2, - (byte) 254, - (byte) 201, - (byte) 120, - (byte) 32, - (byte) 126, - (byte) 2, - (byte) 83, - (byte) 161, - (byte) 238, - (byte) 123, - (byte) 102, - (byte) 230, - (byte) 76, - (byte) 190, - (byte) 225, - (byte) 182, - (byte) 207, - (byte) 228, - (byte) 7, - (byte) 218, - (byte) 117, - (byte) 89, - (byte) 29, - (byte) 191, - (byte) 56, - (byte) 248, - (byte) 185, - (byte) 255, - (byte) 46, - (byte) 18, - (byte) 72, - (byte) 142, - (byte) 82, - (byte) 113, - (byte) 26, - (byte) 4, - (byte) 172, - (byte) 254, - (byte) 178, - (byte) 136, - (byte) 113, - (byte) 115, - (byte) 58, - (byte) 193, - (byte) 89, - (byte) 227, - (byte) 182, - (byte) 246, - (byte) 76, - (byte) 77, - (byte) 108, - (byte) 245, - (byte) 41, - (byte) 31, - (byte) 70, - (byte) 124, - (byte) 249, - (byte) 145, - (byte) 15, - (byte) 78, - (byte) 228, - (byte) 38, - (byte) 241, - (byte) 129, - (byte) 8, - (byte) 176, - (byte) 251, - (byte) 72, - (byte) 248, - (byte) 80, - (byte) 115, - (byte) 244, - (byte) 231, - (byte) 145, - (byte) 191, - (byte) 190, - (byte) 178, - (byte) 168, - (byte) 89, - (byte) 233, - (byte) 69, - (byte) 176, - (byte) 174, - (byte) 140, - (byte) 182, - (byte) 141, - (byte) 81, - (byte) 82, - (byte) 92, - (byte) 79, - (byte) 101, - (byte) 223, - (byte) 100, - (byte) 64, - (byte) 184, - (byte) 215, - (byte) 124, - (byte) 37, - (byte) 21, - (byte) 227, - (byte) 135, - (byte) 102, - (byte) 72, - (byte) 36, - (byte) 219, - (byte) 56, - (byte) 146, - (byte) 90, - (byte) 219, - (byte) 104, - (byte) 227, - (byte) 102, - (byte) 83, - (byte) 12, - (byte) 41, - (byte) 122, - (byte) 173, - (byte) 94, - (byte) 1, - (byte) 174, - (byte) 134, - (byte) 130, - (byte) 104, - (byte) 237, - (byte) 116, - (byte) 249, - (byte) 107, - (byte) 230, - (byte) 130, - (byte) 123, - (byte) 25, - (byte) 162, - (byte) 57, - (byte) 223, - (byte) 193, - (byte) 174, - (byte) 146, - (byte) 193, - (byte) 239, - (byte) 44, - (byte) 246, - (byte) 197, - (byte) 214, - (byte) 80, - (byte) 83, - (byte) 100, - (byte) 66, - (byte) 72, - (byte) 133, - (byte) 137, - (byte) 140, - (byte) 82, - (byte) 2, - (byte) 2, - (byte) 96, - (byte) 9, - (byte) 96, - (byte) 158, - (byte) 134, - (byte) 97, - (byte) 43, - (byte) 129, - (byte) 141, - (byte) 25, - (byte) 183, - (byte) 200, - (byte) 214, - (byte) 57, - (byte) 248, - (byte) 103, - (byte) 222, - (byte) 65, - (byte) 195, - (byte) 15, - (byte) 244, - (byte) 21, - (byte) 180, - (byte) 46, - (byte) 140, - (byte) 130, - (byte) 36, - (byte) 17, - (byte) 194, - (byte) 209, - (byte) 65, - (byte) 254, - (byte) 115, - (byte) 103, - (byte) 152, - (byte) 129, - (byte) 234, - (byte) 235, - (byte) 194, - (byte) 234, - (byte) 170, - (byte) 201, - (byte) 210, - (byte) 154, - }; - SBPMessage sbp = new SBPMessage(0x3c00, 0xff0e, payload); - MsgSolnMeta msg = new MsgSolnMeta(sbp); + byte[] payload = new byte[] {(byte)48,(byte)208,(byte)65,(byte)216,(byte)122,(byte)45,(byte)196,(byte)160,(byte)144,(byte)228,(byte)8,(byte)83,(byte)89,(byte)87,(byte)3,(byte)213,(byte)95,(byte)109,(byte)86,(byte)131,(byte)71,(byte)70,(byte)84,(byte)73,(byte)131,(byte)26,(byte)82,(byte)247,(byte)140,(byte)97,(byte)115,(byte)110,(byte)118,(byte)253,(byte)2,(byte)122,(byte)186,(byte)148,(byte)122,(byte)148,(byte)180,(byte)231,(byte)68,(byte)46,(byte)190,(byte)102,(byte)243,(byte)48,(byte)192,(byte)15,(byte)208,(byte)89,(byte)56,(byte)10,(byte)245,(byte)2,(byte)254,(byte)201,(byte)120,(byte)32,(byte)126,(byte)2,(byte)83,(byte)161,(byte)238,(byte)123,(byte)102,(byte)230,(byte)76,(byte)190,(byte)225,(byte)182,(byte)207,(byte)228,(byte)7,(byte)218,(byte)117,(byte)89,(byte)29,(byte)191,(byte)56,(byte)248,(byte)185,(byte)255,(byte)46,(byte)18,(byte)72,(byte)142,(byte)82,(byte)113,(byte)26,(byte)4,(byte)172,(byte)254,(byte)178,(byte)136,(byte)113,(byte)115,(byte)58,(byte)193,(byte)89,(byte)227,(byte)182,(byte)246,(byte)76,(byte)77,(byte)108,(byte)245,(byte)41,(byte)31,(byte)70,(byte)124,(byte)249,(byte)145,(byte)15,(byte)78,(byte)228,(byte)38,(byte)241,(byte)129,(byte)8,(byte)176,(byte)251,(byte)72,(byte)248,(byte)80,(byte)115,(byte)244,(byte)231,(byte)145,(byte)191,(byte)190,(byte)178,(byte)168,(byte)89,(byte)233,(byte)69,(byte)176,(byte)174,(byte)140,(byte)182,(byte)141,(byte)81,(byte)82,(byte)92,(byte)79,(byte)101,(byte)223,(byte)100,(byte)64,(byte)184,(byte)215,(byte)124,(byte)37,(byte)21,(byte)227,(byte)135,(byte)102,(byte)72,(byte)36,(byte)219,(byte)56,(byte)146,(byte)90,(byte)219,(byte)104,(byte)227,(byte)102,(byte)83,(byte)12,(byte)41,(byte)122,(byte)173,(byte)94,(byte)1,(byte)174,(byte)134,(byte)130,(byte)104,(byte)237,(byte)116,(byte)249,(byte)107,(byte)230,(byte)130,(byte)123,(byte)25,(byte)162,(byte)57,(byte)223,(byte)193,(byte)174,(byte)146,(byte)193,(byte)239,(byte)44,(byte)246,(byte)197,(byte)214,(byte)80,(byte)83,(byte)100,(byte)66,(byte)72,(byte)133,(byte)137,(byte)140,(byte)82,(byte)2,(byte)2,(byte)96,(byte)9,(byte)96,(byte)158,(byte)134,(byte)97,(byte)43,(byte)129,(byte)141,(byte)25,(byte)183,(byte)200,(byte)214,(byte)57,(byte)248,(byte)103,(byte)222,(byte)65,(byte)195,(byte)15,(byte)244,(byte)21,(byte)180,(byte)46,(byte)140,(byte)130,(byte)36,(byte)17,(byte)194,(byte)209,(byte)65,(byte)254,(byte)115,(byte)103,(byte)152,(byte)129,(byte)234,(byte)235,(byte)194,(byte)234,(byte)170,(byte)201,(byte)210,(byte)154, }; + SBPMessage sbp = new SBPMessage( 0x3c00, 0xff0e, payload ); + MsgSolnMeta msg = new MsgSolnMeta( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.age_corrections; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.age_corrections + "' != '" + 21256 + "'", - value.equals(BigInteger.valueOf(21256L))); + org.junit.Assert.assertTrue("'" + msg.age_corrections + "' != '" + 21256 + "'", value.equals(BigInteger.valueOf( 21256L ) ) ); } else { value = value.longValue(); expected = 21256L; @@ -303,9 +50,7 @@ public void test1() throws Throwable { } value = msg.age_gnss; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.age_gnss + "' != '" + 3573765977L + "'", - value.equals(new BigInteger("3573765977"))); + org.junit.Assert.assertTrue("'" + msg.age_gnss + "' != '" + 3573765977L + "'", value.equals( new BigInteger( "3573765977" ) ) ); } else { value = value.longValue(); expected = 3573765977L; @@ -313,9 +58,7 @@ public void test1() throws Throwable { } value = msg.hdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.hdop + "' != '" + 41156 + "'", - value.equals(BigInteger.valueOf(41156L))); + org.junit.Assert.assertTrue("'" + msg.hdop + "' != '" + 41156 + "'", value.equals(BigInteger.valueOf( 41156L ) ) ); } else { value = value.longValue(); expected = 41156L; @@ -323,9 +66,7 @@ public void test1() throws Throwable { } value = msg.pdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pdop + "' != '" + 11642 + "'", - value.equals(BigInteger.valueOf(11642L))); + org.junit.Assert.assertTrue("'" + msg.pdop + "' != '" + 11642 + "'", value.equals(BigInteger.valueOf( 11642L ) ) ); } else { value = value.longValue(); expected = 11642L; @@ -333,9 +74,7 @@ public void test1() throws Throwable { } value = msg.sol_in[0].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[0].flags + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[0].flags + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -343,9 +82,7 @@ public void test1() throws Throwable { } value = msg.sol_in[0].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[0].sensor_type + "' != '" + 95 + "'", - value.equals(BigInteger.valueOf(95L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[0].sensor_type + "' != '" + 95 + "'", value.equals(BigInteger.valueOf( 95L ) ) ); } else { value = value.longValue(); expected = 95L; @@ -353,9 +90,7 @@ public void test1() throws Throwable { } value = msg.sol_in[1].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[1].flags + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[1].flags + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -363,9 +98,7 @@ public void test1() throws Throwable { } value = msg.sol_in[1].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[1].sensor_type + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[1].sensor_type + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -373,9 +106,7 @@ public void test1() throws Throwable { } value = msg.sol_in[2].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[2].flags + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[2].flags + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -383,9 +114,7 @@ public void test1() throws Throwable { } value = msg.sol_in[2].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[2].sensor_type + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[2].sensor_type + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -393,9 +122,7 @@ public void test1() throws Throwable { } value = msg.sol_in[3].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[3].flags + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[3].flags + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -403,9 +130,7 @@ public void test1() throws Throwable { } value = msg.sol_in[3].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[3].sensor_type + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[3].sensor_type + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -413,9 +138,7 @@ public void test1() throws Throwable { } value = msg.sol_in[4].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[4].flags + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[4].flags + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -423,9 +146,7 @@ public void test1() throws Throwable { } value = msg.sol_in[4].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[4].sensor_type + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[4].sensor_type + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -433,9 +154,7 @@ public void test1() throws Throwable { } value = msg.sol_in[5].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[5].flags + "' != '" + 247 + "'", - value.equals(BigInteger.valueOf(247L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[5].flags + "' != '" + 247 + "'", value.equals(BigInteger.valueOf( 247L ) ) ); } else { value = value.longValue(); expected = 247L; @@ -443,9 +162,7 @@ public void test1() throws Throwable { } value = msg.sol_in[5].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[5].sensor_type + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[5].sensor_type + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -453,9 +170,7 @@ public void test1() throws Throwable { } value = msg.sol_in[6].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[6].flags + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[6].flags + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -463,9 +178,7 @@ public void test1() throws Throwable { } value = msg.sol_in[6].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[6].sensor_type + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[6].sensor_type + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -473,9 +186,7 @@ public void test1() throws Throwable { } value = msg.sol_in[7].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[7].flags + "' != '" + 110 + "'", - value.equals(BigInteger.valueOf(110L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[7].flags + "' != '" + 110 + "'", value.equals(BigInteger.valueOf( 110L ) ) ); } else { value = value.longValue(); expected = 110L; @@ -483,9 +194,7 @@ public void test1() throws Throwable { } value = msg.sol_in[7].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[7].sensor_type + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[7].sensor_type + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -493,9 +202,7 @@ public void test1() throws Throwable { } value = msg.sol_in[8].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[8].flags + "' != '" + 253 + "'", - value.equals(BigInteger.valueOf(253L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[8].flags + "' != '" + 253 + "'", value.equals(BigInteger.valueOf( 253L ) ) ); } else { value = value.longValue(); expected = 253L; @@ -503,9 +210,7 @@ public void test1() throws Throwable { } value = msg.sol_in[8].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[8].sensor_type + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[8].sensor_type + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -513,9 +218,7 @@ public void test1() throws Throwable { } value = msg.sol_in[9].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[9].flags + "' != '" + 122 + "'", - value.equals(BigInteger.valueOf(122L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[9].flags + "' != '" + 122 + "'", value.equals(BigInteger.valueOf( 122L ) ) ); } else { value = value.longValue(); expected = 122L; @@ -523,9 +226,7 @@ public void test1() throws Throwable { } value = msg.sol_in[9].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[9].sensor_type + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[9].sensor_type + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -533,9 +234,7 @@ public void test1() throws Throwable { } value = msg.sol_in[10].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[10].flags + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[10].flags + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -543,9 +242,7 @@ public void test1() throws Throwable { } value = msg.sol_in[10].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[10].sensor_type + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[10].sensor_type + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -553,9 +250,7 @@ public void test1() throws Throwable { } value = msg.sol_in[11].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[11].flags + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[11].flags + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -563,9 +258,7 @@ public void test1() throws Throwable { } value = msg.sol_in[11].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[11].sensor_type + "' != '" + 122 + "'", - value.equals(BigInteger.valueOf(122L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[11].sensor_type + "' != '" + 122 + "'", value.equals(BigInteger.valueOf( 122L ) ) ); } else { value = value.longValue(); expected = 122L; @@ -573,9 +266,7 @@ public void test1() throws Throwable { } value = msg.sol_in[12].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[12].flags + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[12].flags + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -583,9 +274,7 @@ public void test1() throws Throwable { } value = msg.sol_in[12].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[12].sensor_type + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[12].sensor_type + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -593,9 +282,7 @@ public void test1() throws Throwable { } value = msg.sol_in[13].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[13].flags + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[13].flags + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -603,9 +290,7 @@ public void test1() throws Throwable { } value = msg.sol_in[13].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[13].sensor_type + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[13].sensor_type + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -613,9 +298,7 @@ public void test1() throws Throwable { } value = msg.sol_in[14].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[14].flags + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[14].flags + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -623,9 +306,7 @@ public void test1() throws Throwable { } value = msg.sol_in[14].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[14].sensor_type + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[14].sensor_type + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -633,9 +314,7 @@ public void test1() throws Throwable { } value = msg.sol_in[15].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[15].flags + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[15].flags + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -643,9 +322,7 @@ public void test1() throws Throwable { } value = msg.sol_in[15].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[15].sensor_type + "' != '" + 243 + "'", - value.equals(BigInteger.valueOf(243L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[15].sensor_type + "' != '" + 243 + "'", value.equals(BigInteger.valueOf( 243L ) ) ); } else { value = value.longValue(); expected = 243L; @@ -653,9 +330,7 @@ public void test1() throws Throwable { } value = msg.sol_in[16].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[16].flags + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[16].flags + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -663,9 +338,7 @@ public void test1() throws Throwable { } value = msg.sol_in[16].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[16].sensor_type + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[16].sensor_type + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -673,9 +346,7 @@ public void test1() throws Throwable { } value = msg.sol_in[17].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[17].flags + "' != '" + 89 + "'", - value.equals(BigInteger.valueOf(89L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[17].flags + "' != '" + 89 + "'", value.equals(BigInteger.valueOf( 89L ) ) ); } else { value = value.longValue(); expected = 89L; @@ -683,9 +354,7 @@ public void test1() throws Throwable { } value = msg.sol_in[17].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[17].sensor_type + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[17].sensor_type + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -693,9 +362,7 @@ public void test1() throws Throwable { } value = msg.sol_in[18].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[18].flags + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[18].flags + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -703,9 +370,7 @@ public void test1() throws Throwable { } value = msg.sol_in[18].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[18].sensor_type + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[18].sensor_type + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -713,9 +378,7 @@ public void test1() throws Throwable { } value = msg.sol_in[19].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[19].flags + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[19].flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -723,9 +386,7 @@ public void test1() throws Throwable { } value = msg.sol_in[19].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[19].sensor_type + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[19].sensor_type + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -733,9 +394,7 @@ public void test1() throws Throwable { } value = msg.sol_in[20].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[20].flags + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[20].flags + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -743,9 +402,7 @@ public void test1() throws Throwable { } value = msg.sol_in[20].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[20].sensor_type + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[20].sensor_type + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -753,9 +410,7 @@ public void test1() throws Throwable { } value = msg.sol_in[21].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[21].flags + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[21].flags + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -763,9 +418,7 @@ public void test1() throws Throwable { } value = msg.sol_in[21].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[21].sensor_type + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[21].sensor_type + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -773,9 +426,7 @@ public void test1() throws Throwable { } value = msg.sol_in[22].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[22].flags + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[22].flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -783,9 +434,7 @@ public void test1() throws Throwable { } value = msg.sol_in[22].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[22].sensor_type + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[22].sensor_type + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -793,9 +442,7 @@ public void test1() throws Throwable { } value = msg.sol_in[23].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[23].flags + "' != '" + 161 + "'", - value.equals(BigInteger.valueOf(161L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[23].flags + "' != '" + 161 + "'", value.equals(BigInteger.valueOf( 161L ) ) ); } else { value = value.longValue(); expected = 161L; @@ -803,9 +450,7 @@ public void test1() throws Throwable { } value = msg.sol_in[23].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[23].sensor_type + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[23].sensor_type + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -813,9 +458,7 @@ public void test1() throws Throwable { } value = msg.sol_in[24].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[24].flags + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[24].flags + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -823,9 +466,7 @@ public void test1() throws Throwable { } value = msg.sol_in[24].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[24].sensor_type + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[24].sensor_type + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -833,9 +474,7 @@ public void test1() throws Throwable { } value = msg.sol_in[25].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[25].flags + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[25].flags + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -843,9 +482,7 @@ public void test1() throws Throwable { } value = msg.sol_in[25].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[25].sensor_type + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[25].sensor_type + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -853,9 +490,7 @@ public void test1() throws Throwable { } value = msg.sol_in[26].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[26].flags + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[26].flags + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -863,9 +498,7 @@ public void test1() throws Throwable { } value = msg.sol_in[26].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[26].sensor_type + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[26].sensor_type + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -873,9 +506,7 @@ public void test1() throws Throwable { } value = msg.sol_in[27].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[27].flags + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[27].flags + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -883,9 +514,7 @@ public void test1() throws Throwable { } value = msg.sol_in[27].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[27].sensor_type + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[27].sensor_type + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -893,9 +522,7 @@ public void test1() throws Throwable { } value = msg.sol_in[28].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[28].flags + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[28].flags + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -903,9 +530,7 @@ public void test1() throws Throwable { } value = msg.sol_in[28].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[28].sensor_type + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[28].sensor_type + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -913,9 +538,7 @@ public void test1() throws Throwable { } value = msg.sol_in[29].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[29].flags + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[29].flags + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -923,9 +546,7 @@ public void test1() throws Throwable { } value = msg.sol_in[29].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[29].sensor_type + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[29].sensor_type + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -933,9 +554,7 @@ public void test1() throws Throwable { } value = msg.sol_in[30].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[30].flags + "' != '" + 89 + "'", - value.equals(BigInteger.valueOf(89L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[30].flags + "' != '" + 89 + "'", value.equals(BigInteger.valueOf( 89L ) ) ); } else { value = value.longValue(); expected = 89L; @@ -943,9 +562,7 @@ public void test1() throws Throwable { } value = msg.sol_in[30].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[30].sensor_type + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[30].sensor_type + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -953,9 +570,7 @@ public void test1() throws Throwable { } value = msg.sol_in[31].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[31].flags + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[31].flags + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -963,9 +578,7 @@ public void test1() throws Throwable { } value = msg.sol_in[31].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[31].sensor_type + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[31].sensor_type + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -973,9 +586,7 @@ public void test1() throws Throwable { } value = msg.sol_in[32].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[32].flags + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[32].flags + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -983,9 +594,7 @@ public void test1() throws Throwable { } value = msg.sol_in[32].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[32].sensor_type + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[32].sensor_type + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -993,9 +602,7 @@ public void test1() throws Throwable { } value = msg.sol_in[33].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[33].flags + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[33].flags + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -1003,9 +610,7 @@ public void test1() throws Throwable { } value = msg.sol_in[33].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[33].sensor_type + "' != '" + 185 + "'", - value.equals(BigInteger.valueOf(185L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[33].sensor_type + "' != '" + 185 + "'", value.equals(BigInteger.valueOf( 185L ) ) ); } else { value = value.longValue(); expected = 185L; @@ -1013,9 +618,7 @@ public void test1() throws Throwable { } value = msg.sol_in[34].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[34].flags + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[34].flags + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -1023,9 +626,7 @@ public void test1() throws Throwable { } value = msg.sol_in[34].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[34].sensor_type + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[34].sensor_type + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -1033,9 +634,7 @@ public void test1() throws Throwable { } value = msg.sol_in[35].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[35].flags + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[35].flags + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -1043,9 +642,7 @@ public void test1() throws Throwable { } value = msg.sol_in[35].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[35].sensor_type + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[35].sensor_type + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -1053,9 +650,7 @@ public void test1() throws Throwable { } value = msg.sol_in[36].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[36].flags + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[36].flags + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -1063,9 +658,7 @@ public void test1() throws Throwable { } value = msg.sol_in[36].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[36].sensor_type + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[36].sensor_type + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -1073,9 +666,7 @@ public void test1() throws Throwable { } value = msg.sol_in[37].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[37].flags + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[37].flags + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1083,9 +674,7 @@ public void test1() throws Throwable { } value = msg.sol_in[37].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[37].sensor_type + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[37].sensor_type + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -1093,9 +682,7 @@ public void test1() throws Throwable { } value = msg.sol_in[38].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[38].flags + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[38].flags + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -1103,9 +690,7 @@ public void test1() throws Throwable { } value = msg.sol_in[38].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[38].sensor_type + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[38].sensor_type + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -1113,9 +698,7 @@ public void test1() throws Throwable { } value = msg.sol_in[39].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[39].flags + "' != '" + 136 + "'", - value.equals(BigInteger.valueOf(136L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[39].flags + "' != '" + 136 + "'", value.equals(BigInteger.valueOf( 136L ) ) ); } else { value = value.longValue(); expected = 136L; @@ -1123,9 +706,7 @@ public void test1() throws Throwable { } value = msg.sol_in[39].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[39].sensor_type + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[39].sensor_type + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -1133,9 +714,7 @@ public void test1() throws Throwable { } value = msg.sol_in[40].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[40].flags + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[40].flags + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1143,9 +722,7 @@ public void test1() throws Throwable { } value = msg.sol_in[40].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[40].sensor_type + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[40].sensor_type + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -1153,9 +730,7 @@ public void test1() throws Throwable { } value = msg.sol_in[41].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[41].flags + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[41].flags + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -1163,9 +738,7 @@ public void test1() throws Throwable { } value = msg.sol_in[41].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[41].sensor_type + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[41].sensor_type + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -1173,9 +746,7 @@ public void test1() throws Throwable { } value = msg.sol_in[42].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[42].flags + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[42].flags + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1183,9 +754,7 @@ public void test1() throws Throwable { } value = msg.sol_in[42].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[42].sensor_type + "' != '" + 89 + "'", - value.equals(BigInteger.valueOf(89L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[42].sensor_type + "' != '" + 89 + "'", value.equals(BigInteger.valueOf( 89L ) ) ); } else { value = value.longValue(); expected = 89L; @@ -1193,9 +762,7 @@ public void test1() throws Throwable { } value = msg.sol_in[43].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[43].flags + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[43].flags + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -1203,9 +770,7 @@ public void test1() throws Throwable { } value = msg.sol_in[43].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[43].sensor_type + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[43].sensor_type + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -1213,9 +778,7 @@ public void test1() throws Throwable { } value = msg.sol_in[44].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[44].flags + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[44].flags + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -1223,9 +786,7 @@ public void test1() throws Throwable { } value = msg.sol_in[44].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[44].sensor_type + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[44].sensor_type + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -1233,9 +794,7 @@ public void test1() throws Throwable { } value = msg.sol_in[45].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[45].flags + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[45].flags + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -1243,9 +802,7 @@ public void test1() throws Throwable { } value = msg.sol_in[45].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[45].sensor_type + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[45].sensor_type + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -1253,9 +810,7 @@ public void test1() throws Throwable { } value = msg.sol_in[46].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[46].flags + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[46].flags + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -1263,9 +818,7 @@ public void test1() throws Throwable { } value = msg.sol_in[46].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[46].sensor_type + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[46].sensor_type + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -1273,9 +826,7 @@ public void test1() throws Throwable { } value = msg.sol_in[47].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[47].flags + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[47].flags + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -1283,9 +834,7 @@ public void test1() throws Throwable { } value = msg.sol_in[47].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[47].sensor_type + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[47].sensor_type + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -1293,9 +842,7 @@ public void test1() throws Throwable { } value = msg.sol_in[48].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[48].flags + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[48].flags + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -1303,9 +850,7 @@ public void test1() throws Throwable { } value = msg.sol_in[48].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[48].sensor_type + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[48].sensor_type + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -1313,9 +858,7 @@ public void test1() throws Throwable { } value = msg.sol_in[49].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[49].flags + "' != '" + 78 + "'", - value.equals(BigInteger.valueOf(78L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[49].flags + "' != '" + 78 + "'", value.equals(BigInteger.valueOf( 78L ) ) ); } else { value = value.longValue(); expected = 78L; @@ -1323,9 +866,7 @@ public void test1() throws Throwable { } value = msg.sol_in[49].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[49].sensor_type + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[49].sensor_type + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -1333,9 +874,7 @@ public void test1() throws Throwable { } value = msg.sol_in[50].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[50].flags + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[50].flags + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -1343,9 +882,7 @@ public void test1() throws Throwable { } value = msg.sol_in[50].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[50].sensor_type + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[50].sensor_type + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -1353,9 +890,7 @@ public void test1() throws Throwable { } value = msg.sol_in[51].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[51].flags + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[51].flags + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -1363,9 +898,7 @@ public void test1() throws Throwable { } value = msg.sol_in[51].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[51].sensor_type + "' != '" + 241 + "'", - value.equals(BigInteger.valueOf(241L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[51].sensor_type + "' != '" + 241 + "'", value.equals(BigInteger.valueOf( 241L ) ) ); } else { value = value.longValue(); expected = 241L; @@ -1373,9 +906,7 @@ public void test1() throws Throwable { } value = msg.sol_in[52].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[52].flags + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[52].flags + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -1383,9 +914,7 @@ public void test1() throws Throwable { } value = msg.sol_in[52].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[52].sensor_type + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[52].sensor_type + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -1393,9 +922,7 @@ public void test1() throws Throwable { } value = msg.sol_in[53].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[53].flags + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[53].flags + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -1403,9 +930,7 @@ public void test1() throws Throwable { } value = msg.sol_in[53].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[53].sensor_type + "' != '" + 251 + "'", - value.equals(BigInteger.valueOf(251L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[53].sensor_type + "' != '" + 251 + "'", value.equals(BigInteger.valueOf( 251L ) ) ); } else { value = value.longValue(); expected = 251L; @@ -1413,9 +938,7 @@ public void test1() throws Throwable { } value = msg.sol_in[54].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[54].flags + "' != '" + 80 + "'", - value.equals(BigInteger.valueOf(80L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[54].flags + "' != '" + 80 + "'", value.equals(BigInteger.valueOf( 80L ) ) ); } else { value = value.longValue(); expected = 80L; @@ -1423,9 +946,7 @@ public void test1() throws Throwable { } value = msg.sol_in[54].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[54].sensor_type + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[54].sensor_type + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -1433,9 +954,7 @@ public void test1() throws Throwable { } value = msg.sol_in[55].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[55].flags + "' != '" + 244 + "'", - value.equals(BigInteger.valueOf(244L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[55].flags + "' != '" + 244 + "'", value.equals(BigInteger.valueOf( 244L ) ) ); } else { value = value.longValue(); expected = 244L; @@ -1443,9 +962,7 @@ public void test1() throws Throwable { } value = msg.sol_in[55].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[55].sensor_type + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[55].sensor_type + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1453,9 +970,7 @@ public void test1() throws Throwable { } value = msg.sol_in[56].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[56].flags + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[56].flags + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -1463,9 +978,7 @@ public void test1() throws Throwable { } value = msg.sol_in[56].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[56].sensor_type + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[56].sensor_type + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -1473,9 +986,7 @@ public void test1() throws Throwable { } value = msg.sol_in[57].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[57].flags + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[57].flags + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -1483,9 +994,7 @@ public void test1() throws Throwable { } value = msg.sol_in[57].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[57].sensor_type + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[57].sensor_type + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -1493,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.sol_in[58].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[58].flags + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[58].flags + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -1503,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.sol_in[58].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[58].sensor_type + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[58].sensor_type + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -1513,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.sol_in[59].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[59].flags + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[59].flags + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -1523,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.sol_in[59].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[59].sensor_type + "' != '" + 89 + "'", - value.equals(BigInteger.valueOf(89L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[59].sensor_type + "' != '" + 89 + "'", value.equals(BigInteger.valueOf( 89L ) ) ); } else { value = value.longValue(); expected = 89L; @@ -1533,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.sol_in[60].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[60].flags + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[60].flags + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -1543,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.sol_in[60].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[60].sensor_type + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[60].sensor_type + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -1553,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.sol_in[61].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[61].flags + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[61].flags + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -1563,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.sol_in[61].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[61].sensor_type + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[61].sensor_type + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -1573,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.sol_in[62].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[62].flags + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[62].flags + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -1583,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.sol_in[62].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[62].sensor_type + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[62].sensor_type + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -1593,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.sol_in[63].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[63].flags + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[63].flags + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -1603,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.sol_in[63].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[63].sensor_type + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[63].sensor_type + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -1613,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.sol_in[64].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[64].flags + "' != '" + 79 + "'", - value.equals(BigInteger.valueOf(79L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[64].flags + "' != '" + 79 + "'", value.equals(BigInteger.valueOf( 79L ) ) ); } else { value = value.longValue(); expected = 79L; @@ -1623,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.sol_in[64].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[64].sensor_type + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[64].sensor_type + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -1633,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.sol_in[65].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[65].flags + "' != '" + 223 + "'", - value.equals(BigInteger.valueOf(223L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[65].flags + "' != '" + 223 + "'", value.equals(BigInteger.valueOf( 223L ) ) ); } else { value = value.longValue(); expected = 223L; @@ -1643,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.sol_in[65].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[65].sensor_type + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[65].sensor_type + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -1653,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.sol_in[66].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[66].flags + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[66].flags + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -1663,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.sol_in[66].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[66].sensor_type + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[66].sensor_type + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -1673,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.sol_in[67].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[67].flags + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[67].flags + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -1683,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.sol_in[67].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[67].sensor_type + "' != '" + 184 + "'", - value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[67].sensor_type + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -1693,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.sol_in[68].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[68].flags + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[68].flags + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -1703,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.sol_in[68].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[68].sensor_type + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[68].sensor_type + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -1713,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.sol_in[69].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[69].flags + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[69].flags + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1723,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.sol_in[69].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[69].sensor_type + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[69].sensor_type + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -1733,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.sol_in[70].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[70].flags + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[70].flags + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -1743,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.sol_in[70].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[70].sensor_type + "' != '" + 135 + "'", - value.equals(BigInteger.valueOf(135L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[70].sensor_type + "' != '" + 135 + "'", value.equals(BigInteger.valueOf( 135L ) ) ); } else { value = value.longValue(); expected = 135L; @@ -1753,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.sol_in[71].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[71].flags + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[71].flags + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -1763,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.sol_in[71].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[71].sensor_type + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[71].sensor_type + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -1773,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.sol_in[72].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[72].flags + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[72].flags + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -1783,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.sol_in[72].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[72].sensor_type + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[72].sensor_type + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -1793,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.sol_in[73].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[73].flags + "' != '" + 90 + "'", - value.equals(BigInteger.valueOf(90L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[73].flags + "' != '" + 90 + "'", value.equals(BigInteger.valueOf( 90L ) ) ); } else { value = value.longValue(); expected = 90L; @@ -1803,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.sol_in[73].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[73].sensor_type + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[73].sensor_type + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -1813,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.sol_in[74].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[74].flags + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[74].flags + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -1823,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.sol_in[74].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[74].sensor_type + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[74].sensor_type + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -1833,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.sol_in[75].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[75].flags + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[75].flags + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -1843,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.sol_in[75].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[75].sensor_type + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[75].sensor_type + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1853,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.sol_in[76].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[76].flags + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[76].flags + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1863,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.sol_in[76].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[76].sensor_type + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[76].sensor_type + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -1873,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.sol_in[77].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[77].flags + "' != '" + 122 + "'", - value.equals(BigInteger.valueOf(122L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[77].flags + "' != '" + 122 + "'", value.equals(BigInteger.valueOf( 122L ) ) ); } else { value = value.longValue(); expected = 122L; @@ -1883,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.sol_in[77].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[77].sensor_type + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[77].sensor_type + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -1893,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.sol_in[78].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[78].flags + "' != '" + 94 + "'", - value.equals(BigInteger.valueOf(94L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[78].flags + "' != '" + 94 + "'", value.equals(BigInteger.valueOf( 94L ) ) ); } else { value = value.longValue(); expected = 94L; @@ -1903,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.sol_in[78].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[78].sensor_type + "' != '" + 173 + "'", - value.equals(BigInteger.valueOf(173L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[78].sensor_type + "' != '" + 173 + "'", value.equals(BigInteger.valueOf( 173L ) ) ); } else { value = value.longValue(); expected = 173L; @@ -1913,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.sol_in[79].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[79].flags + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[79].flags + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -1923,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.sol_in[79].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[79].sensor_type + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[79].sensor_type + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1933,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.sol_in[80].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[80].flags + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[80].flags + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -1943,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.sol_in[80].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[80].sensor_type + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[80].sensor_type + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -1953,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.sol_in[81].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[81].flags + "' != '" + 237 + "'", - value.equals(BigInteger.valueOf(237L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[81].flags + "' != '" + 237 + "'", value.equals(BigInteger.valueOf( 237L ) ) ); } else { value = value.longValue(); expected = 237L; @@ -1963,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.sol_in[81].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[81].sensor_type + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[81].sensor_type + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -1973,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.sol_in[82].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[82].flags + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[82].flags + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -1983,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.sol_in[82].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[82].sensor_type + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[82].sensor_type + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1993,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.sol_in[83].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[83].flags + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[83].flags + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -2003,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.sol_in[83].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[83].sensor_type + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[83].sensor_type + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -2013,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.sol_in[84].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[84].flags + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[84].flags + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -2023,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.sol_in[84].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[84].sensor_type + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[84].sensor_type + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -2033,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.sol_in[85].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[85].flags + "' != '" + 162 + "'", - value.equals(BigInteger.valueOf(162L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[85].flags + "' != '" + 162 + "'", value.equals(BigInteger.valueOf( 162L ) ) ); } else { value = value.longValue(); expected = 162L; @@ -2043,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.sol_in[85].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[85].sensor_type + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[85].sensor_type + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -2053,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.sol_in[86].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[86].flags + "' != '" + 223 + "'", - value.equals(BigInteger.valueOf(223L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[86].flags + "' != '" + 223 + "'", value.equals(BigInteger.valueOf( 223L ) ) ); } else { value = value.longValue(); expected = 223L; @@ -2063,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.sol_in[86].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[86].sensor_type + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[86].sensor_type + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -2073,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.sol_in[87].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[87].flags + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[87].flags + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -2083,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.sol_in[87].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[87].sensor_type + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[87].sensor_type + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -2093,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.sol_in[88].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[88].flags + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[88].flags + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -2103,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.sol_in[88].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[88].sensor_type + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[88].sensor_type + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -2113,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.sol_in[89].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[89].flags + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[89].flags + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -2123,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.sol_in[89].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[89].sensor_type + "' != '" + 239 + "'", - value.equals(BigInteger.valueOf(239L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[89].sensor_type + "' != '" + 239 + "'", value.equals(BigInteger.valueOf( 239L ) ) ); } else { value = value.longValue(); expected = 239L; @@ -2133,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.sol_in[90].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[90].flags + "' != '" + 197 + "'", - value.equals(BigInteger.valueOf(197L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[90].flags + "' != '" + 197 + "'", value.equals(BigInteger.valueOf( 197L ) ) ); } else { value = value.longValue(); expected = 197L; @@ -2143,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.sol_in[90].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[90].sensor_type + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[90].sensor_type + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -2153,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.sol_in[91].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[91].flags + "' != '" + 80 + "'", - value.equals(BigInteger.valueOf(80L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[91].flags + "' != '" + 80 + "'", value.equals(BigInteger.valueOf( 80L ) ) ); } else { value = value.longValue(); expected = 80L; @@ -2163,9 +1538,7 @@ public void test1() throws Throwable { } value = msg.sol_in[91].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[91].sensor_type + "' != '" + 214 + "'", - value.equals(BigInteger.valueOf(214L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[91].sensor_type + "' != '" + 214 + "'", value.equals(BigInteger.valueOf( 214L ) ) ); } else { value = value.longValue(); expected = 214L; @@ -2173,9 +1546,7 @@ public void test1() throws Throwable { } value = msg.sol_in[92].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[92].flags + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[92].flags + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -2183,9 +1554,7 @@ public void test1() throws Throwable { } value = msg.sol_in[92].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[92].sensor_type + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[92].sensor_type + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -2193,9 +1562,7 @@ public void test1() throws Throwable { } value = msg.sol_in[93].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[93].flags + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[93].flags + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -2203,9 +1570,7 @@ public void test1() throws Throwable { } value = msg.sol_in[93].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[93].sensor_type + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[93].sensor_type + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -2213,9 +1578,7 @@ public void test1() throws Throwable { } value = msg.sol_in[94].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[94].flags + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[94].flags + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -2223,9 +1586,7 @@ public void test1() throws Throwable { } value = msg.sol_in[94].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[94].sensor_type + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[94].sensor_type + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -2233,9 +1594,7 @@ public void test1() throws Throwable { } value = msg.sol_in[95].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[95].flags + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[95].flags + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -2243,9 +1602,7 @@ public void test1() throws Throwable { } value = msg.sol_in[95].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[95].sensor_type + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[95].sensor_type + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -2253,9 +1610,7 @@ public void test1() throws Throwable { } value = msg.sol_in[96].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[96].flags + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[96].flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -2263,9 +1618,7 @@ public void test1() throws Throwable { } value = msg.sol_in[96].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[96].sensor_type + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[96].sensor_type + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -2273,9 +1626,7 @@ public void test1() throws Throwable { } value = msg.sol_in[97].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[97].flags + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[97].flags + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -2283,9 +1634,7 @@ public void test1() throws Throwable { } value = msg.sol_in[97].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[97].sensor_type + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[97].sensor_type + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -2293,9 +1642,7 @@ public void test1() throws Throwable { } value = msg.sol_in[98].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[98].flags + "' != '" + 158 + "'", - value.equals(BigInteger.valueOf(158L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[98].flags + "' != '" + 158 + "'", value.equals(BigInteger.valueOf( 158L ) ) ); } else { value = value.longValue(); expected = 158L; @@ -2303,9 +1650,7 @@ public void test1() throws Throwable { } value = msg.sol_in[98].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[98].sensor_type + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[98].sensor_type + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -2313,9 +1658,7 @@ public void test1() throws Throwable { } value = msg.sol_in[99].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[99].flags + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[99].flags + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -2323,9 +1666,7 @@ public void test1() throws Throwable { } value = msg.sol_in[99].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[99].sensor_type + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[99].sensor_type + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -2333,9 +1674,7 @@ public void test1() throws Throwable { } value = msg.sol_in[100].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[100].flags + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[100].flags + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -2343,9 +1682,7 @@ public void test1() throws Throwable { } value = msg.sol_in[100].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[100].sensor_type + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[100].sensor_type + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -2353,9 +1690,7 @@ public void test1() throws Throwable { } value = msg.sol_in[101].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[101].flags + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[101].flags + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -2363,9 +1698,7 @@ public void test1() throws Throwable { } value = msg.sol_in[101].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[101].sensor_type + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[101].sensor_type + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -2373,9 +1706,7 @@ public void test1() throws Throwable { } value = msg.sol_in[102].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[102].flags + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[102].flags + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -2383,9 +1714,7 @@ public void test1() throws Throwable { } value = msg.sol_in[102].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[102].sensor_type + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[102].sensor_type + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -2393,9 +1722,7 @@ public void test1() throws Throwable { } value = msg.sol_in[103].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[103].flags + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[103].flags + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -2403,9 +1730,7 @@ public void test1() throws Throwable { } value = msg.sol_in[103].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[103].sensor_type + "' != '" + 214 + "'", - value.equals(BigInteger.valueOf(214L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[103].sensor_type + "' != '" + 214 + "'", value.equals(BigInteger.valueOf( 214L ) ) ); } else { value = value.longValue(); expected = 214L; @@ -2413,9 +1738,7 @@ public void test1() throws Throwable { } value = msg.sol_in[104].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[104].flags + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[104].flags + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -2423,9 +1746,7 @@ public void test1() throws Throwable { } value = msg.sol_in[104].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[104].sensor_type + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[104].sensor_type + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -2433,9 +1754,7 @@ public void test1() throws Throwable { } value = msg.sol_in[105].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[105].flags + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[105].flags + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -2443,9 +1762,7 @@ public void test1() throws Throwable { } value = msg.sol_in[105].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[105].sensor_type + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[105].sensor_type + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -2453,9 +1770,7 @@ public void test1() throws Throwable { } value = msg.sol_in[106].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[106].flags + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[106].flags + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -2463,9 +1778,7 @@ public void test1() throws Throwable { } value = msg.sol_in[106].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[106].sensor_type + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[106].sensor_type + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -2473,9 +1786,7 @@ public void test1() throws Throwable { } value = msg.sol_in[107].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[107].flags + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[107].flags + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -2483,9 +1794,7 @@ public void test1() throws Throwable { } value = msg.sol_in[107].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[107].sensor_type + "' != '" + 244 + "'", - value.equals(BigInteger.valueOf(244L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[107].sensor_type + "' != '" + 244 + "'", value.equals(BigInteger.valueOf( 244L ) ) ); } else { value = value.longValue(); expected = 244L; @@ -2493,9 +1802,7 @@ public void test1() throws Throwable { } value = msg.sol_in[108].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[108].flags + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[108].flags + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -2503,9 +1810,7 @@ public void test1() throws Throwable { } value = msg.sol_in[108].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[108].sensor_type + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[108].sensor_type + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -2513,9 +1818,7 @@ public void test1() throws Throwable { } value = msg.sol_in[109].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[109].flags + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[109].flags + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -2523,9 +1826,7 @@ public void test1() throws Throwable { } value = msg.sol_in[109].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[109].sensor_type + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[109].sensor_type + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -2533,9 +1834,7 @@ public void test1() throws Throwable { } value = msg.sol_in[110].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[110].flags + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[110].flags + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -2543,9 +1842,7 @@ public void test1() throws Throwable { } value = msg.sol_in[110].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[110].sensor_type + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[110].sensor_type + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -2553,9 +1850,7 @@ public void test1() throws Throwable { } value = msg.sol_in[111].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[111].flags + "' != '" + 209 + "'", - value.equals(BigInteger.valueOf(209L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[111].flags + "' != '" + 209 + "'", value.equals(BigInteger.valueOf( 209L ) ) ); } else { value = value.longValue(); expected = 209L; @@ -2563,9 +1858,7 @@ public void test1() throws Throwable { } value = msg.sol_in[111].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[111].sensor_type + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[111].sensor_type + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -2573,9 +1866,7 @@ public void test1() throws Throwable { } value = msg.sol_in[112].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[112].flags + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[112].flags + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -2583,9 +1874,7 @@ public void test1() throws Throwable { } value = msg.sol_in[112].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[112].sensor_type + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[112].sensor_type + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -2593,9 +1882,7 @@ public void test1() throws Throwable { } value = msg.sol_in[113].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[113].flags + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[113].flags + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -2603,9 +1890,7 @@ public void test1() throws Throwable { } value = msg.sol_in[113].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[113].sensor_type + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[113].sensor_type + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -2613,9 +1898,7 @@ public void test1() throws Throwable { } value = msg.sol_in[114].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[114].flags + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[114].flags + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -2623,9 +1906,7 @@ public void test1() throws Throwable { } value = msg.sol_in[114].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[114].sensor_type + "' != '" + 152 + "'", - value.equals(BigInteger.valueOf(152L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[114].sensor_type + "' != '" + 152 + "'", value.equals(BigInteger.valueOf( 152L ) ) ); } else { value = value.longValue(); expected = 152L; @@ -2633,9 +1914,7 @@ public void test1() throws Throwable { } value = msg.sol_in[115].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[115].flags + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[115].flags + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -2643,9 +1922,7 @@ public void test1() throws Throwable { } value = msg.sol_in[115].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[115].sensor_type + "' != '" + 234 + "'", - value.equals(BigInteger.valueOf(234L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[115].sensor_type + "' != '" + 234 + "'", value.equals(BigInteger.valueOf( 234L ) ) ); } else { value = value.longValue(); expected = 234L; @@ -2653,9 +1930,7 @@ public void test1() throws Throwable { } value = msg.sol_in[116].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[116].flags + "' != '" + 234 + "'", - value.equals(BigInteger.valueOf(234L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[116].flags + "' != '" + 234 + "'", value.equals(BigInteger.valueOf( 234L ) ) ); } else { value = value.longValue(); expected = 234L; @@ -2663,9 +1938,7 @@ public void test1() throws Throwable { } value = msg.sol_in[116].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[116].sensor_type + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[116].sensor_type + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -2673,9 +1946,7 @@ public void test1() throws Throwable { } value = msg.sol_in[117].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[117].flags + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[117].flags + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -2683,9 +1954,7 @@ public void test1() throws Throwable { } value = msg.sol_in[117].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[117].sensor_type + "' != '" + 170 + "'", - value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[117].sensor_type + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -2693,9 +1962,7 @@ public void test1() throws Throwable { } value = msg.sol_in[118].flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[118].flags + "' != '" + 154 + "'", - value.equals(BigInteger.valueOf(154L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[118].flags + "' != '" + 154 + "'", value.equals(BigInteger.valueOf( 154L ) ) ); } else { value = value.longValue(); expected = 154L; @@ -2703,9 +1970,7 @@ public void test1() throws Throwable { } value = msg.sol_in[118].sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_in[118].sensor_type + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.sol_in[118].sensor_type + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -2713,9 +1978,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 3628191792L + "'", - value.equals(new BigInteger("3628191792"))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 3628191792L + "'", value.equals( new BigInteger( "3628191792" ) ) ); } else { value = value.longValue(); expected = 3628191792L; @@ -2723,9 +1986,7 @@ public void test1() throws Throwable { } value = msg.vdop; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.vdop + "' != '" + 58512 + "'", - value.equals(BigInteger.valueOf(58512L))); + org.junit.Assert.assertTrue("'" + msg.vdop + "' != '" + 58512 + "'", value.equals(BigInteger.valueOf( 58512L ) ) ); } else { value = value.longValue(); expected = 58512L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrCodeBiasesTest.java b/java/test/auto_check_sbp_ssr_MsgSsrCodeBiasesTest.java index 103734a78..cf9c4cf4c 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrCodeBiasesTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrCodeBiasesTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodeBiases.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodeBiases.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrCodeBiases; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrCodeBiasesTest { @@ -27,273 +32,17 @@ public class auto_check_sbp_ssr_MsgSsrCodeBiasesTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrCodeBiasesTest.test1"); - byte[] payload = - new byte[] { - (byte) 208, - (byte) 90, - (byte) 19, - (byte) 23, - (byte) 9, - (byte) 66, - (byte) 133, - (byte) 241, - (byte) 254, - (byte) 132, - (byte) 51, - (byte) 4, - (byte) 131, - (byte) 240, - (byte) 120, - (byte) 83, - (byte) 148, - (byte) 209, - (byte) 213, - (byte) 62, - (byte) 228, - (byte) 232, - (byte) 71, - (byte) 66, - (byte) 188, - (byte) 210, - (byte) 128, - (byte) 54, - (byte) 131, - (byte) 152, - (byte) 129, - (byte) 111, - (byte) 139, - (byte) 242, - (byte) 177, - (byte) 145, - (byte) 44, - (byte) 9, - (byte) 245, - (byte) 207, - (byte) 241, - (byte) 202, - (byte) 150, - (byte) 141, - (byte) 50, - (byte) 159, - (byte) 220, - (byte) 139, - (byte) 37, - (byte) 187, - (byte) 98, - (byte) 191, - (byte) 23, - (byte) 128, - (byte) 136, - (byte) 167, - (byte) 200, - (byte) 6, - (byte) 211, - (byte) 90, - (byte) 23, - (byte) 244, - (byte) 138, - (byte) 215, - (byte) 209, - (byte) 139, - (byte) 13, - (byte) 101, - (byte) 32, - (byte) 7, - (byte) 18, - (byte) 29, - (byte) 70, - (byte) 250, - (byte) 109, - (byte) 73, - (byte) 202, - (byte) 79, - (byte) 144, - (byte) 9, - (byte) 146, - (byte) 69, - (byte) 241, - (byte) 52, - (byte) 22, - (byte) 99, - (byte) 98, - (byte) 204, - (byte) 3, - (byte) 171, - (byte) 230, - (byte) 180, - (byte) 75, - (byte) 62, - (byte) 145, - (byte) 86, - (byte) 130, - (byte) 31, - (byte) 30, - (byte) 155, - (byte) 37, - (byte) 18, - (byte) 55, - (byte) 210, - (byte) 39, - (byte) 127, - (byte) 242, - (byte) 66, - (byte) 13, - (byte) 237, - (byte) 152, - (byte) 170, - (byte) 212, - (byte) 15, - (byte) 246, - (byte) 59, - (byte) 94, - (byte) 180, - (byte) 195, - (byte) 157, - (byte) 69, - (byte) 100, - (byte) 119, - (byte) 16, - (byte) 68, - (byte) 179, - (byte) 175, - (byte) 144, - (byte) 113, - (byte) 81, - (byte) 82, - (byte) 30, - (byte) 151, - (byte) 21, - (byte) 109, - (byte) 41, - (byte) 225, - (byte) 8, - (byte) 77, - (byte) 164, - (byte) 157, - (byte) 0, - (byte) 73, - (byte) 30, - (byte) 6, - (byte) 78, - (byte) 81, - (byte) 143, - (byte) 116, - (byte) 240, - (byte) 151, - (byte) 55, - (byte) 185, - (byte) 169, - (byte) 254, - (byte) 51, - (byte) 39, - (byte) 74, - (byte) 175, - (byte) 247, - (byte) 34, - (byte) 97, - (byte) 74, - (byte) 97, - (byte) 176, - (byte) 48, - (byte) 236, - (byte) 173, - (byte) 12, - (byte) 174, - (byte) 101, - (byte) 130, - (byte) 30, - (byte) 169, - (byte) 193, - (byte) 190, - (byte) 204, - (byte) 196, - (byte) 123, - (byte) 107, - (byte) 25, - (byte) 225, - (byte) 74, - (byte) 9, - (byte) 10, - (byte) 55, - (byte) 3, - (byte) 131, - (byte) 246, - (byte) 99, - (byte) 133, - (byte) 34, - (byte) 227, - (byte) 203, - (byte) 68, - (byte) 18, - (byte) 97, - (byte) 223, - (byte) 89, - (byte) 192, - (byte) 246, - (byte) 50, - (byte) 69, - (byte) 91, - (byte) 10, - (byte) 151, - (byte) 74, - (byte) 118, - (byte) 110, - (byte) 36, - (byte) 168, - (byte) 247, - (byte) 160, - (byte) 77, - (byte) 179, - (byte) 141, - (byte) 178, - (byte) 99, - (byte) 191, - (byte) 120, - (byte) 77, - (byte) 192, - (byte) 91, - (byte) 224, - (byte) 1, - (byte) 226, - (byte) 50, - (byte) 87, - (byte) 146, - (byte) 148, - (byte) 238, - (byte) 100, - (byte) 179, - (byte) 125, - (byte) 227, - (byte) 215, - (byte) 104, - (byte) 184, - (byte) 31, - (byte) 57, - (byte) 90, - (byte) 79, - (byte) 21, - (byte) 156, - (byte) 245, - (byte) 81, - (byte) 60, - (byte) 93, - (byte) 170, - (byte) 60, - (byte) 200, - (byte) 167, - (byte) 13, - }; - SBPMessage sbp = new SBPMessage(0x5727, 0x5e1, payload); - MsgSsrCodeBiases msg = new MsgSsrCodeBiases(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrCodeBiasesTest.test1"); + byte[] payload = new byte[] {(byte)208,(byte)90,(byte)19,(byte)23,(byte)9,(byte)66,(byte)133,(byte)241,(byte)254,(byte)132,(byte)51,(byte)4,(byte)131,(byte)240,(byte)120,(byte)83,(byte)148,(byte)209,(byte)213,(byte)62,(byte)228,(byte)232,(byte)71,(byte)66,(byte)188,(byte)210,(byte)128,(byte)54,(byte)131,(byte)152,(byte)129,(byte)111,(byte)139,(byte)242,(byte)177,(byte)145,(byte)44,(byte)9,(byte)245,(byte)207,(byte)241,(byte)202,(byte)150,(byte)141,(byte)50,(byte)159,(byte)220,(byte)139,(byte)37,(byte)187,(byte)98,(byte)191,(byte)23,(byte)128,(byte)136,(byte)167,(byte)200,(byte)6,(byte)211,(byte)90,(byte)23,(byte)244,(byte)138,(byte)215,(byte)209,(byte)139,(byte)13,(byte)101,(byte)32,(byte)7,(byte)18,(byte)29,(byte)70,(byte)250,(byte)109,(byte)73,(byte)202,(byte)79,(byte)144,(byte)9,(byte)146,(byte)69,(byte)241,(byte)52,(byte)22,(byte)99,(byte)98,(byte)204,(byte)3,(byte)171,(byte)230,(byte)180,(byte)75,(byte)62,(byte)145,(byte)86,(byte)130,(byte)31,(byte)30,(byte)155,(byte)37,(byte)18,(byte)55,(byte)210,(byte)39,(byte)127,(byte)242,(byte)66,(byte)13,(byte)237,(byte)152,(byte)170,(byte)212,(byte)15,(byte)246,(byte)59,(byte)94,(byte)180,(byte)195,(byte)157,(byte)69,(byte)100,(byte)119,(byte)16,(byte)68,(byte)179,(byte)175,(byte)144,(byte)113,(byte)81,(byte)82,(byte)30,(byte)151,(byte)21,(byte)109,(byte)41,(byte)225,(byte)8,(byte)77,(byte)164,(byte)157,(byte)0,(byte)73,(byte)30,(byte)6,(byte)78,(byte)81,(byte)143,(byte)116,(byte)240,(byte)151,(byte)55,(byte)185,(byte)169,(byte)254,(byte)51,(byte)39,(byte)74,(byte)175,(byte)247,(byte)34,(byte)97,(byte)74,(byte)97,(byte)176,(byte)48,(byte)236,(byte)173,(byte)12,(byte)174,(byte)101,(byte)130,(byte)30,(byte)169,(byte)193,(byte)190,(byte)204,(byte)196,(byte)123,(byte)107,(byte)25,(byte)225,(byte)74,(byte)9,(byte)10,(byte)55,(byte)3,(byte)131,(byte)246,(byte)99,(byte)133,(byte)34,(byte)227,(byte)203,(byte)68,(byte)18,(byte)97,(byte)223,(byte)89,(byte)192,(byte)246,(byte)50,(byte)69,(byte)91,(byte)10,(byte)151,(byte)74,(byte)118,(byte)110,(byte)36,(byte)168,(byte)247,(byte)160,(byte)77,(byte)179,(byte)141,(byte)178,(byte)99,(byte)191,(byte)120,(byte)77,(byte)192,(byte)91,(byte)224,(byte)1,(byte)226,(byte)50,(byte)87,(byte)146,(byte)148,(byte)238,(byte)100,(byte)179,(byte)125,(byte)227,(byte)215,(byte)104,(byte)184,(byte)31,(byte)57,(byte)90,(byte)79,(byte)21,(byte)156,(byte)245,(byte)81,(byte)60,(byte)93,(byte)170,(byte)60,(byte)200,(byte)167,(byte)13, }; + SBPMessage sbp = new SBPMessage( 0x5727, 0x5e1, payload ); + MsgSsrCodeBiases msg = new MsgSsrCodeBiases( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.biases[0].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[0].code + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.biases[0].code + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -301,9 +50,7 @@ public void test1() throws Throwable { } value = msg.biases[0].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[0].value + "' != '" + -31996 + "'", - value.equals(BigInteger.valueOf(-31996L))); + org.junit.Assert.assertTrue("'" + msg.biases[0].value + "' != '" + -31996 + "'", value.equals(BigInteger.valueOf( -31996L ) ) ); } else { value = value.longValue(); expected = -31996L; @@ -311,9 +58,7 @@ public void test1() throws Throwable { } value = msg.biases[1].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[1].code + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.biases[1].code + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -321,9 +66,7 @@ public void test1() throws Throwable { } value = msg.biases[1].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[1].value + "' != '" + 21368 + "'", - value.equals(BigInteger.valueOf(21368L))); + org.junit.Assert.assertTrue("'" + msg.biases[1].value + "' != '" + 21368 + "'", value.equals(BigInteger.valueOf( 21368L ) ) ); } else { value = value.longValue(); expected = 21368L; @@ -331,9 +74,7 @@ public void test1() throws Throwable { } value = msg.biases[2].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[2].code + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.biases[2].code + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -341,9 +82,7 @@ public void test1() throws Throwable { } value = msg.biases[2].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[2].value + "' != '" + -10799 + "'", - value.equals(BigInteger.valueOf(-10799L))); + org.junit.Assert.assertTrue("'" + msg.biases[2].value + "' != '" + -10799 + "'", value.equals(BigInteger.valueOf( -10799L ) ) ); } else { value = value.longValue(); expected = -10799L; @@ -351,9 +90,7 @@ public void test1() throws Throwable { } value = msg.biases[3].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[3].code + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.biases[3].code + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -361,9 +98,7 @@ public void test1() throws Throwable { } value = msg.biases[3].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[3].value + "' != '" + -5916 + "'", - value.equals(BigInteger.valueOf(-5916L))); + org.junit.Assert.assertTrue("'" + msg.biases[3].value + "' != '" + -5916 + "'", value.equals(BigInteger.valueOf( -5916L ) ) ); } else { value = value.longValue(); expected = -5916L; @@ -371,9 +106,7 @@ public void test1() throws Throwable { } value = msg.biases[4].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[4].code + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.biases[4].code + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -381,9 +114,7 @@ public void test1() throws Throwable { } value = msg.biases[4].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[4].value + "' != '" + -17342 + "'", - value.equals(BigInteger.valueOf(-17342L))); + org.junit.Assert.assertTrue("'" + msg.biases[4].value + "' != '" + -17342 + "'", value.equals(BigInteger.valueOf( -17342L ) ) ); } else { value = value.longValue(); expected = -17342L; @@ -391,9 +122,7 @@ public void test1() throws Throwable { } value = msg.biases[5].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[5].code + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.biases[5].code + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -401,9 +130,7 @@ public void test1() throws Throwable { } value = msg.biases[5].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[5].value + "' != '" + 13952 + "'", - value.equals(BigInteger.valueOf(13952L))); + org.junit.Assert.assertTrue("'" + msg.biases[5].value + "' != '" + 13952 + "'", value.equals(BigInteger.valueOf( 13952L ) ) ); } else { value = value.longValue(); expected = 13952L; @@ -411,9 +138,7 @@ public void test1() throws Throwable { } value = msg.biases[6].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[6].code + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.biases[6].code + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -421,9 +146,7 @@ public void test1() throws Throwable { } value = msg.biases[6].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[6].value + "' != '" + -32360 + "'", - value.equals(BigInteger.valueOf(-32360L))); + org.junit.Assert.assertTrue("'" + msg.biases[6].value + "' != '" + -32360 + "'", value.equals(BigInteger.valueOf( -32360L ) ) ); } else { value = value.longValue(); expected = -32360L; @@ -431,9 +154,7 @@ public void test1() throws Throwable { } value = msg.biases[7].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[7].code + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.biases[7].code + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -441,9 +162,7 @@ public void test1() throws Throwable { } value = msg.biases[7].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[7].value + "' != '" + -3445 + "'", - value.equals(BigInteger.valueOf(-3445L))); + org.junit.Assert.assertTrue("'" + msg.biases[7].value + "' != '" + -3445 + "'", value.equals(BigInteger.valueOf( -3445L ) ) ); } else { value = value.longValue(); expected = -3445L; @@ -451,9 +170,7 @@ public void test1() throws Throwable { } value = msg.biases[8].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[8].code + "' != '" + 177 + "'", - value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.biases[8].code + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -461,9 +178,7 @@ public void test1() throws Throwable { } value = msg.biases[8].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[8].value + "' != '" + 11409 + "'", - value.equals(BigInteger.valueOf(11409L))); + org.junit.Assert.assertTrue("'" + msg.biases[8].value + "' != '" + 11409 + "'", value.equals(BigInteger.valueOf( 11409L ) ) ); } else { value = value.longValue(); expected = 11409L; @@ -471,9 +186,7 @@ public void test1() throws Throwable { } value = msg.biases[9].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[9].code + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.biases[9].code + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -481,9 +194,7 @@ public void test1() throws Throwable { } value = msg.biases[9].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[9].value + "' != '" + -12299 + "'", - value.equals(BigInteger.valueOf(-12299L))); + org.junit.Assert.assertTrue("'" + msg.biases[9].value + "' != '" + -12299 + "'", value.equals(BigInteger.valueOf( -12299L ) ) ); } else { value = value.longValue(); expected = -12299L; @@ -491,9 +202,7 @@ public void test1() throws Throwable { } value = msg.biases[10].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[10].code + "' != '" + 241 + "'", - value.equals(BigInteger.valueOf(241L))); + org.junit.Assert.assertTrue("'" + msg.biases[10].code + "' != '" + 241 + "'", value.equals(BigInteger.valueOf( 241L ) ) ); } else { value = value.longValue(); expected = 241L; @@ -501,9 +210,7 @@ public void test1() throws Throwable { } value = msg.biases[10].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[10].value + "' != '" + -26934 + "'", - value.equals(BigInteger.valueOf(-26934L))); + org.junit.Assert.assertTrue("'" + msg.biases[10].value + "' != '" + -26934 + "'", value.equals(BigInteger.valueOf( -26934L ) ) ); } else { value = value.longValue(); expected = -26934L; @@ -511,9 +218,7 @@ public void test1() throws Throwable { } value = msg.biases[11].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[11].code + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.biases[11].code + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -521,9 +226,7 @@ public void test1() throws Throwable { } value = msg.biases[11].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[11].value + "' != '" + -24782 + "'", - value.equals(BigInteger.valueOf(-24782L))); + org.junit.Assert.assertTrue("'" + msg.biases[11].value + "' != '" + -24782 + "'", value.equals(BigInteger.valueOf( -24782L ) ) ); } else { value = value.longValue(); expected = -24782L; @@ -531,9 +234,7 @@ public void test1() throws Throwable { } value = msg.biases[12].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[12].code + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.biases[12].code + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -541,9 +242,7 @@ public void test1() throws Throwable { } value = msg.biases[12].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[12].value + "' != '" + 9611 + "'", - value.equals(BigInteger.valueOf(9611L))); + org.junit.Assert.assertTrue("'" + msg.biases[12].value + "' != '" + 9611 + "'", value.equals(BigInteger.valueOf( 9611L ) ) ); } else { value = value.longValue(); expected = 9611L; @@ -551,9 +250,7 @@ public void test1() throws Throwable { } value = msg.biases[13].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[13].code + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.biases[13].code + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -561,9 +258,7 @@ public void test1() throws Throwable { } value = msg.biases[13].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[13].value + "' != '" + -16542 + "'", - value.equals(BigInteger.valueOf(-16542L))); + org.junit.Assert.assertTrue("'" + msg.biases[13].value + "' != '" + -16542 + "'", value.equals(BigInteger.valueOf( -16542L ) ) ); } else { value = value.longValue(); expected = -16542L; @@ -571,9 +266,7 @@ public void test1() throws Throwable { } value = msg.biases[14].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[14].code + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.biases[14].code + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -581,9 +274,7 @@ public void test1() throws Throwable { } value = msg.biases[14].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[14].value + "' != '" + -30592 + "'", - value.equals(BigInteger.valueOf(-30592L))); + org.junit.Assert.assertTrue("'" + msg.biases[14].value + "' != '" + -30592 + "'", value.equals(BigInteger.valueOf( -30592L ) ) ); } else { value = value.longValue(); expected = -30592L; @@ -591,9 +282,7 @@ public void test1() throws Throwable { } value = msg.biases[15].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[15].code + "' != '" + 167 + "'", - value.equals(BigInteger.valueOf(167L))); + org.junit.Assert.assertTrue("'" + msg.biases[15].code + "' != '" + 167 + "'", value.equals(BigInteger.valueOf( 167L ) ) ); } else { value = value.longValue(); expected = 167L; @@ -601,9 +290,7 @@ public void test1() throws Throwable { } value = msg.biases[15].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[15].value + "' != '" + 1736 + "'", - value.equals(BigInteger.valueOf(1736L))); + org.junit.Assert.assertTrue("'" + msg.biases[15].value + "' != '" + 1736 + "'", value.equals(BigInteger.valueOf( 1736L ) ) ); } else { value = value.longValue(); expected = 1736L; @@ -611,9 +298,7 @@ public void test1() throws Throwable { } value = msg.biases[16].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[16].code + "' != '" + 211 + "'", - value.equals(BigInteger.valueOf(211L))); + org.junit.Assert.assertTrue("'" + msg.biases[16].code + "' != '" + 211 + "'", value.equals(BigInteger.valueOf( 211L ) ) ); } else { value = value.longValue(); expected = 211L; @@ -621,9 +306,7 @@ public void test1() throws Throwable { } value = msg.biases[16].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[16].value + "' != '" + 5978 + "'", - value.equals(BigInteger.valueOf(5978L))); + org.junit.Assert.assertTrue("'" + msg.biases[16].value + "' != '" + 5978 + "'", value.equals(BigInteger.valueOf( 5978L ) ) ); } else { value = value.longValue(); expected = 5978L; @@ -631,9 +314,7 @@ public void test1() throws Throwable { } value = msg.biases[17].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[17].code + "' != '" + 244 + "'", - value.equals(BigInteger.valueOf(244L))); + org.junit.Assert.assertTrue("'" + msg.biases[17].code + "' != '" + 244 + "'", value.equals(BigInteger.valueOf( 244L ) ) ); } else { value = value.longValue(); expected = 244L; @@ -641,9 +322,7 @@ public void test1() throws Throwable { } value = msg.biases[17].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[17].value + "' != '" + -10358 + "'", - value.equals(BigInteger.valueOf(-10358L))); + org.junit.Assert.assertTrue("'" + msg.biases[17].value + "' != '" + -10358 + "'", value.equals(BigInteger.valueOf( -10358L ) ) ); } else { value = value.longValue(); expected = -10358L; @@ -651,9 +330,7 @@ public void test1() throws Throwable { } value = msg.biases[18].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[18].code + "' != '" + 209 + "'", - value.equals(BigInteger.valueOf(209L))); + org.junit.Assert.assertTrue("'" + msg.biases[18].code + "' != '" + 209 + "'", value.equals(BigInteger.valueOf( 209L ) ) ); } else { value = value.longValue(); expected = 209L; @@ -661,9 +338,7 @@ public void test1() throws Throwable { } value = msg.biases[18].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[18].value + "' != '" + 3467 + "'", - value.equals(BigInteger.valueOf(3467L))); + org.junit.Assert.assertTrue("'" + msg.biases[18].value + "' != '" + 3467 + "'", value.equals(BigInteger.valueOf( 3467L ) ) ); } else { value = value.longValue(); expected = 3467L; @@ -671,9 +346,7 @@ public void test1() throws Throwable { } value = msg.biases[19].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[19].code + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.biases[19].code + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -681,9 +354,7 @@ public void test1() throws Throwable { } value = msg.biases[19].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[19].value + "' != '" + 1824 + "'", - value.equals(BigInteger.valueOf(1824L))); + org.junit.Assert.assertTrue("'" + msg.biases[19].value + "' != '" + 1824 + "'", value.equals(BigInteger.valueOf( 1824L ) ) ); } else { value = value.longValue(); expected = 1824L; @@ -691,9 +362,7 @@ public void test1() throws Throwable { } value = msg.biases[20].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[20].code + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.biases[20].code + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -701,9 +370,7 @@ public void test1() throws Throwable { } value = msg.biases[20].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[20].value + "' != '" + 17949 + "'", - value.equals(BigInteger.valueOf(17949L))); + org.junit.Assert.assertTrue("'" + msg.biases[20].value + "' != '" + 17949 + "'", value.equals(BigInteger.valueOf( 17949L ) ) ); } else { value = value.longValue(); expected = 17949L; @@ -711,9 +378,7 @@ public void test1() throws Throwable { } value = msg.biases[21].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[21].code + "' != '" + 250 + "'", - value.equals(BigInteger.valueOf(250L))); + org.junit.Assert.assertTrue("'" + msg.biases[21].code + "' != '" + 250 + "'", value.equals(BigInteger.valueOf( 250L ) ) ); } else { value = value.longValue(); expected = 250L; @@ -721,9 +386,7 @@ public void test1() throws Throwable { } value = msg.biases[21].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[21].value + "' != '" + 18797 + "'", - value.equals(BigInteger.valueOf(18797L))); + org.junit.Assert.assertTrue("'" + msg.biases[21].value + "' != '" + 18797 + "'", value.equals(BigInteger.valueOf( 18797L ) ) ); } else { value = value.longValue(); expected = 18797L; @@ -731,9 +394,7 @@ public void test1() throws Throwable { } value = msg.biases[22].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[22].code + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.biases[22].code + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -741,9 +402,7 @@ public void test1() throws Throwable { } value = msg.biases[22].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[22].value + "' != '" + -28593 + "'", - value.equals(BigInteger.valueOf(-28593L))); + org.junit.Assert.assertTrue("'" + msg.biases[22].value + "' != '" + -28593 + "'", value.equals(BigInteger.valueOf( -28593L ) ) ); } else { value = value.longValue(); expected = -28593L; @@ -751,9 +410,7 @@ public void test1() throws Throwable { } value = msg.biases[23].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[23].code + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.biases[23].code + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -761,9 +418,7 @@ public void test1() throws Throwable { } value = msg.biases[23].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[23].value + "' != '" + 17810 + "'", - value.equals(BigInteger.valueOf(17810L))); + org.junit.Assert.assertTrue("'" + msg.biases[23].value + "' != '" + 17810 + "'", value.equals(BigInteger.valueOf( 17810L ) ) ); } else { value = value.longValue(); expected = 17810L; @@ -771,9 +426,7 @@ public void test1() throws Throwable { } value = msg.biases[24].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[24].code + "' != '" + 241 + "'", - value.equals(BigInteger.valueOf(241L))); + org.junit.Assert.assertTrue("'" + msg.biases[24].code + "' != '" + 241 + "'", value.equals(BigInteger.valueOf( 241L ) ) ); } else { value = value.longValue(); expected = 241L; @@ -781,9 +434,7 @@ public void test1() throws Throwable { } value = msg.biases[24].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[24].value + "' != '" + 5684 + "'", - value.equals(BigInteger.valueOf(5684L))); + org.junit.Assert.assertTrue("'" + msg.biases[24].value + "' != '" + 5684 + "'", value.equals(BigInteger.valueOf( 5684L ) ) ); } else { value = value.longValue(); expected = 5684L; @@ -791,9 +442,7 @@ public void test1() throws Throwable { } value = msg.biases[25].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[25].code + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.biases[25].code + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -801,9 +450,7 @@ public void test1() throws Throwable { } value = msg.biases[25].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[25].value + "' != '" + -13214 + "'", - value.equals(BigInteger.valueOf(-13214L))); + org.junit.Assert.assertTrue("'" + msg.biases[25].value + "' != '" + -13214 + "'", value.equals(BigInteger.valueOf( -13214L ) ) ); } else { value = value.longValue(); expected = -13214L; @@ -811,9 +458,7 @@ public void test1() throws Throwable { } value = msg.biases[26].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[26].code + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.biases[26].code + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -821,9 +466,7 @@ public void test1() throws Throwable { } value = msg.biases[26].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[26].value + "' != '" + -6485 + "'", - value.equals(BigInteger.valueOf(-6485L))); + org.junit.Assert.assertTrue("'" + msg.biases[26].value + "' != '" + -6485 + "'", value.equals(BigInteger.valueOf( -6485L ) ) ); } else { value = value.longValue(); expected = -6485L; @@ -831,9 +474,7 @@ public void test1() throws Throwable { } value = msg.biases[27].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[27].code + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.biases[27].code + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -841,9 +482,7 @@ public void test1() throws Throwable { } value = msg.biases[27].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[27].value + "' != '" + 15947 + "'", - value.equals(BigInteger.valueOf(15947L))); + org.junit.Assert.assertTrue("'" + msg.biases[27].value + "' != '" + 15947 + "'", value.equals(BigInteger.valueOf( 15947L ) ) ); } else { value = value.longValue(); expected = 15947L; @@ -851,9 +490,7 @@ public void test1() throws Throwable { } value = msg.biases[28].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[28].code + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.biases[28].code + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -861,9 +498,7 @@ public void test1() throws Throwable { } value = msg.biases[28].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[28].value + "' != '" + -32170 + "'", - value.equals(BigInteger.valueOf(-32170L))); + org.junit.Assert.assertTrue("'" + msg.biases[28].value + "' != '" + -32170 + "'", value.equals(BigInteger.valueOf( -32170L ) ) ); } else { value = value.longValue(); expected = -32170L; @@ -871,9 +506,7 @@ public void test1() throws Throwable { } value = msg.biases[29].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[29].code + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.biases[29].code + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -881,9 +514,7 @@ public void test1() throws Throwable { } value = msg.biases[29].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[29].value + "' != '" + -25826 + "'", - value.equals(BigInteger.valueOf(-25826L))); + org.junit.Assert.assertTrue("'" + msg.biases[29].value + "' != '" + -25826 + "'", value.equals(BigInteger.valueOf( -25826L ) ) ); } else { value = value.longValue(); expected = -25826L; @@ -891,9 +522,7 @@ public void test1() throws Throwable { } value = msg.biases[30].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[30].code + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.biases[30].code + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -901,9 +530,7 @@ public void test1() throws Throwable { } value = msg.biases[30].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[30].value + "' != '" + 14098 + "'", - value.equals(BigInteger.valueOf(14098L))); + org.junit.Assert.assertTrue("'" + msg.biases[30].value + "' != '" + 14098 + "'", value.equals(BigInteger.valueOf( 14098L ) ) ); } else { value = value.longValue(); expected = 14098L; @@ -911,9 +538,7 @@ public void test1() throws Throwable { } value = msg.biases[31].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[31].code + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.biases[31].code + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -921,9 +546,7 @@ public void test1() throws Throwable { } value = msg.biases[31].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[31].value + "' != '" + 32551 + "'", - value.equals(BigInteger.valueOf(32551L))); + org.junit.Assert.assertTrue("'" + msg.biases[31].value + "' != '" + 32551 + "'", value.equals(BigInteger.valueOf( 32551L ) ) ); } else { value = value.longValue(); expected = 32551L; @@ -931,9 +554,7 @@ public void test1() throws Throwable { } value = msg.biases[32].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[32].code + "' != '" + 242 + "'", - value.equals(BigInteger.valueOf(242L))); + org.junit.Assert.assertTrue("'" + msg.biases[32].code + "' != '" + 242 + "'", value.equals(BigInteger.valueOf( 242L ) ) ); } else { value = value.longValue(); expected = 242L; @@ -941,9 +562,7 @@ public void test1() throws Throwable { } value = msg.biases[32].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[32].value + "' != '" + 3394 + "'", - value.equals(BigInteger.valueOf(3394L))); + org.junit.Assert.assertTrue("'" + msg.biases[32].value + "' != '" + 3394 + "'", value.equals(BigInteger.valueOf( 3394L ) ) ); } else { value = value.longValue(); expected = 3394L; @@ -951,9 +570,7 @@ public void test1() throws Throwable { } value = msg.biases[33].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[33].code + "' != '" + 237 + "'", - value.equals(BigInteger.valueOf(237L))); + org.junit.Assert.assertTrue("'" + msg.biases[33].code + "' != '" + 237 + "'", value.equals(BigInteger.valueOf( 237L ) ) ); } else { value = value.longValue(); expected = 237L; @@ -961,9 +578,7 @@ public void test1() throws Throwable { } value = msg.biases[33].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[33].value + "' != '" + -21864 + "'", - value.equals(BigInteger.valueOf(-21864L))); + org.junit.Assert.assertTrue("'" + msg.biases[33].value + "' != '" + -21864 + "'", value.equals(BigInteger.valueOf( -21864L ) ) ); } else { value = value.longValue(); expected = -21864L; @@ -971,9 +586,7 @@ public void test1() throws Throwable { } value = msg.biases[34].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[34].code + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.biases[34].code + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -981,9 +594,7 @@ public void test1() throws Throwable { } value = msg.biases[34].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[34].value + "' != '" + -2545 + "'", - value.equals(BigInteger.valueOf(-2545L))); + org.junit.Assert.assertTrue("'" + msg.biases[34].value + "' != '" + -2545 + "'", value.equals(BigInteger.valueOf( -2545L ) ) ); } else { value = value.longValue(); expected = -2545L; @@ -991,9 +602,7 @@ public void test1() throws Throwable { } value = msg.biases[35].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[35].code + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.biases[35].code + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -1001,9 +610,7 @@ public void test1() throws Throwable { } value = msg.biases[35].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[35].value + "' != '" + -19362 + "'", - value.equals(BigInteger.valueOf(-19362L))); + org.junit.Assert.assertTrue("'" + msg.biases[35].value + "' != '" + -19362 + "'", value.equals(BigInteger.valueOf( -19362L ) ) ); } else { value = value.longValue(); expected = -19362L; @@ -1011,9 +618,7 @@ public void test1() throws Throwable { } value = msg.biases[36].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[36].code + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.biases[36].code + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -1021,9 +626,7 @@ public void test1() throws Throwable { } value = msg.biases[36].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[36].value + "' != '" + 17821 + "'", - value.equals(BigInteger.valueOf(17821L))); + org.junit.Assert.assertTrue("'" + msg.biases[36].value + "' != '" + 17821 + "'", value.equals(BigInteger.valueOf( 17821L ) ) ); } else { value = value.longValue(); expected = 17821L; @@ -1031,9 +634,7 @@ public void test1() throws Throwable { } value = msg.biases[37].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[37].code + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.biases[37].code + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -1041,9 +642,7 @@ public void test1() throws Throwable { } value = msg.biases[37].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[37].value + "' != '" + 4215 + "'", - value.equals(BigInteger.valueOf(4215L))); + org.junit.Assert.assertTrue("'" + msg.biases[37].value + "' != '" + 4215 + "'", value.equals(BigInteger.valueOf( 4215L ) ) ); } else { value = value.longValue(); expected = 4215L; @@ -1051,9 +650,7 @@ public void test1() throws Throwable { } value = msg.biases[38].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[38].code + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.biases[38].code + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -1061,9 +658,7 @@ public void test1() throws Throwable { } value = msg.biases[38].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[38].value + "' != '" + -20557 + "'", - value.equals(BigInteger.valueOf(-20557L))); + org.junit.Assert.assertTrue("'" + msg.biases[38].value + "' != '" + -20557 + "'", value.equals(BigInteger.valueOf( -20557L ) ) ); } else { value = value.longValue(); expected = -20557L; @@ -1071,9 +666,7 @@ public void test1() throws Throwable { } value = msg.biases[39].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[39].code + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.biases[39].code + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -1081,9 +674,7 @@ public void test1() throws Throwable { } value = msg.biases[39].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[39].value + "' != '" + 20849 + "'", - value.equals(BigInteger.valueOf(20849L))); + org.junit.Assert.assertTrue("'" + msg.biases[39].value + "' != '" + 20849 + "'", value.equals(BigInteger.valueOf( 20849L ) ) ); } else { value = value.longValue(); expected = 20849L; @@ -1091,9 +682,7 @@ public void test1() throws Throwable { } value = msg.biases[40].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[40].code + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.biases[40].code + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -1101,9 +690,7 @@ public void test1() throws Throwable { } value = msg.biases[40].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[40].value + "' != '" + -26850 + "'", - value.equals(BigInteger.valueOf(-26850L))); + org.junit.Assert.assertTrue("'" + msg.biases[40].value + "' != '" + -26850 + "'", value.equals(BigInteger.valueOf( -26850L ) ) ); } else { value = value.longValue(); expected = -26850L; @@ -1111,9 +698,7 @@ public void test1() throws Throwable { } value = msg.biases[41].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[41].code + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.biases[41].code + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -1121,9 +706,7 @@ public void test1() throws Throwable { } value = msg.biases[41].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[41].value + "' != '" + 10605 + "'", - value.equals(BigInteger.valueOf(10605L))); + org.junit.Assert.assertTrue("'" + msg.biases[41].value + "' != '" + 10605 + "'", value.equals(BigInteger.valueOf( 10605L ) ) ); } else { value = value.longValue(); expected = 10605L; @@ -1131,9 +714,7 @@ public void test1() throws Throwable { } value = msg.biases[42].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[42].code + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.biases[42].code + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -1141,9 +722,7 @@ public void test1() throws Throwable { } value = msg.biases[42].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[42].value + "' != '" + 19720 + "'", - value.equals(BigInteger.valueOf(19720L))); + org.junit.Assert.assertTrue("'" + msg.biases[42].value + "' != '" + 19720 + "'", value.equals(BigInteger.valueOf( 19720L ) ) ); } else { value = value.longValue(); expected = 19720L; @@ -1151,9 +730,7 @@ public void test1() throws Throwable { } value = msg.biases[43].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[43].code + "' != '" + 164 + "'", - value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.biases[43].code + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -1161,9 +738,7 @@ public void test1() throws Throwable { } value = msg.biases[43].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[43].value + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.biases[43].value + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -1171,9 +746,7 @@ public void test1() throws Throwable { } value = msg.biases[44].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[44].code + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.biases[44].code + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -1181,9 +754,7 @@ public void test1() throws Throwable { } value = msg.biases[44].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[44].value + "' != '" + 1566 + "'", - value.equals(BigInteger.valueOf(1566L))); + org.junit.Assert.assertTrue("'" + msg.biases[44].value + "' != '" + 1566 + "'", value.equals(BigInteger.valueOf( 1566L ) ) ); } else { value = value.longValue(); expected = 1566L; @@ -1191,9 +762,7 @@ public void test1() throws Throwable { } value = msg.biases[45].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[45].code + "' != '" + 78 + "'", - value.equals(BigInteger.valueOf(78L))); + org.junit.Assert.assertTrue("'" + msg.biases[45].code + "' != '" + 78 + "'", value.equals(BigInteger.valueOf( 78L ) ) ); } else { value = value.longValue(); expected = 78L; @@ -1201,9 +770,7 @@ public void test1() throws Throwable { } value = msg.biases[45].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[45].value + "' != '" + -28847 + "'", - value.equals(BigInteger.valueOf(-28847L))); + org.junit.Assert.assertTrue("'" + msg.biases[45].value + "' != '" + -28847 + "'", value.equals(BigInteger.valueOf( -28847L ) ) ); } else { value = value.longValue(); expected = -28847L; @@ -1211,9 +778,7 @@ public void test1() throws Throwable { } value = msg.biases[46].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[46].code + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.biases[46].code + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1221,9 +786,7 @@ public void test1() throws Throwable { } value = msg.biases[46].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[46].value + "' != '" + -26640 + "'", - value.equals(BigInteger.valueOf(-26640L))); + org.junit.Assert.assertTrue("'" + msg.biases[46].value + "' != '" + -26640 + "'", value.equals(BigInteger.valueOf( -26640L ) ) ); } else { value = value.longValue(); expected = -26640L; @@ -1231,9 +794,7 @@ public void test1() throws Throwable { } value = msg.biases[47].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[47].code + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.biases[47].code + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -1241,9 +802,7 @@ public void test1() throws Throwable { } value = msg.biases[47].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[47].value + "' != '" + -22087 + "'", - value.equals(BigInteger.valueOf(-22087L))); + org.junit.Assert.assertTrue("'" + msg.biases[47].value + "' != '" + -22087 + "'", value.equals(BigInteger.valueOf( -22087L ) ) ); } else { value = value.longValue(); expected = -22087L; @@ -1251,9 +810,7 @@ public void test1() throws Throwable { } value = msg.biases[48].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[48].code + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.biases[48].code + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -1261,9 +818,7 @@ public void test1() throws Throwable { } value = msg.biases[48].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[48].value + "' != '" + 10035 + "'", - value.equals(BigInteger.valueOf(10035L))); + org.junit.Assert.assertTrue("'" + msg.biases[48].value + "' != '" + 10035 + "'", value.equals(BigInteger.valueOf( 10035L ) ) ); } else { value = value.longValue(); expected = 10035L; @@ -1271,9 +826,7 @@ public void test1() throws Throwable { } value = msg.biases[49].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[49].code + "' != '" + 74 + "'", - value.equals(BigInteger.valueOf(74L))); + org.junit.Assert.assertTrue("'" + msg.biases[49].code + "' != '" + 74 + "'", value.equals(BigInteger.valueOf( 74L ) ) ); } else { value = value.longValue(); expected = 74L; @@ -1281,9 +834,7 @@ public void test1() throws Throwable { } value = msg.biases[49].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[49].value + "' != '" + -2129 + "'", - value.equals(BigInteger.valueOf(-2129L))); + org.junit.Assert.assertTrue("'" + msg.biases[49].value + "' != '" + -2129 + "'", value.equals(BigInteger.valueOf( -2129L ) ) ); } else { value = value.longValue(); expected = -2129L; @@ -1291,9 +842,7 @@ public void test1() throws Throwable { } value = msg.biases[50].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[50].code + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.biases[50].code + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -1301,9 +850,7 @@ public void test1() throws Throwable { } value = msg.biases[50].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[50].value + "' != '" + 19041 + "'", - value.equals(BigInteger.valueOf(19041L))); + org.junit.Assert.assertTrue("'" + msg.biases[50].value + "' != '" + 19041 + "'", value.equals(BigInteger.valueOf( 19041L ) ) ); } else { value = value.longValue(); expected = 19041L; @@ -1311,9 +858,7 @@ public void test1() throws Throwable { } value = msg.biases[51].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[51].code + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.biases[51].code + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -1321,9 +866,7 @@ public void test1() throws Throwable { } value = msg.biases[51].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[51].value + "' != '" + 12464 + "'", - value.equals(BigInteger.valueOf(12464L))); + org.junit.Assert.assertTrue("'" + msg.biases[51].value + "' != '" + 12464 + "'", value.equals(BigInteger.valueOf( 12464L ) ) ); } else { value = value.longValue(); expected = 12464L; @@ -1331,9 +874,7 @@ public void test1() throws Throwable { } value = msg.biases[52].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[52].code + "' != '" + 236 + "'", - value.equals(BigInteger.valueOf(236L))); + org.junit.Assert.assertTrue("'" + msg.biases[52].code + "' != '" + 236 + "'", value.equals(BigInteger.valueOf( 236L ) ) ); } else { value = value.longValue(); expected = 236L; @@ -1341,9 +882,7 @@ public void test1() throws Throwable { } value = msg.biases[52].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[52].value + "' != '" + 3245 + "'", - value.equals(BigInteger.valueOf(3245L))); + org.junit.Assert.assertTrue("'" + msg.biases[52].value + "' != '" + 3245 + "'", value.equals(BigInteger.valueOf( 3245L ) ) ); } else { value = value.longValue(); expected = 3245L; @@ -1351,9 +890,7 @@ public void test1() throws Throwable { } value = msg.biases[53].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[53].code + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.biases[53].code + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -1361,9 +898,7 @@ public void test1() throws Throwable { } value = msg.biases[53].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[53].value + "' != '" + -32155 + "'", - value.equals(BigInteger.valueOf(-32155L))); + org.junit.Assert.assertTrue("'" + msg.biases[53].value + "' != '" + -32155 + "'", value.equals(BigInteger.valueOf( -32155L ) ) ); } else { value = value.longValue(); expected = -32155L; @@ -1371,9 +906,7 @@ public void test1() throws Throwable { } value = msg.biases[54].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[54].code + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.biases[54].code + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -1381,9 +914,7 @@ public void test1() throws Throwable { } value = msg.biases[54].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[54].value + "' != '" + -15959 + "'", - value.equals(BigInteger.valueOf(-15959L))); + org.junit.Assert.assertTrue("'" + msg.biases[54].value + "' != '" + -15959 + "'", value.equals(BigInteger.valueOf( -15959L ) ) ); } else { value = value.longValue(); expected = -15959L; @@ -1391,9 +922,7 @@ public void test1() throws Throwable { } value = msg.biases[55].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[55].code + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.biases[55].code + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -1401,9 +930,7 @@ public void test1() throws Throwable { } value = msg.biases[55].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[55].value + "' != '" + -15156 + "'", - value.equals(BigInteger.valueOf(-15156L))); + org.junit.Assert.assertTrue("'" + msg.biases[55].value + "' != '" + -15156 + "'", value.equals(BigInteger.valueOf( -15156L ) ) ); } else { value = value.longValue(); expected = -15156L; @@ -1411,9 +938,7 @@ public void test1() throws Throwable { } value = msg.biases[56].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[56].code + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.biases[56].code + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -1421,9 +946,7 @@ public void test1() throws Throwable { } value = msg.biases[56].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[56].value + "' != '" + 6507 + "'", - value.equals(BigInteger.valueOf(6507L))); + org.junit.Assert.assertTrue("'" + msg.biases[56].value + "' != '" + 6507 + "'", value.equals(BigInteger.valueOf( 6507L ) ) ); } else { value = value.longValue(); expected = 6507L; @@ -1431,9 +954,7 @@ public void test1() throws Throwable { } value = msg.biases[57].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[57].code + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.biases[57].code + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -1441,9 +962,7 @@ public void test1() throws Throwable { } value = msg.biases[57].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[57].value + "' != '" + 2378 + "'", - value.equals(BigInteger.valueOf(2378L))); + org.junit.Assert.assertTrue("'" + msg.biases[57].value + "' != '" + 2378 + "'", value.equals(BigInteger.valueOf( 2378L ) ) ); } else { value = value.longValue(); expected = 2378L; @@ -1451,9 +970,7 @@ public void test1() throws Throwable { } value = msg.biases[58].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[58].code + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.biases[58].code + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -1461,9 +978,7 @@ public void test1() throws Throwable { } value = msg.biases[58].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[58].value + "' != '" + 823 + "'", - value.equals(BigInteger.valueOf(823L))); + org.junit.Assert.assertTrue("'" + msg.biases[58].value + "' != '" + 823 + "'", value.equals(BigInteger.valueOf( 823L ) ) ); } else { value = value.longValue(); expected = 823L; @@ -1471,9 +986,7 @@ public void test1() throws Throwable { } value = msg.biases[59].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[59].code + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.biases[59].code + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -1481,9 +994,7 @@ public void test1() throws Throwable { } value = msg.biases[59].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[59].value + "' != '" + 25590 + "'", - value.equals(BigInteger.valueOf(25590L))); + org.junit.Assert.assertTrue("'" + msg.biases[59].value + "' != '" + 25590 + "'", value.equals(BigInteger.valueOf( 25590L ) ) ); } else { value = value.longValue(); expected = 25590L; @@ -1491,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.biases[60].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[60].code + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.biases[60].code + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -1501,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.biases[60].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[60].value + "' != '" + -7390 + "'", - value.equals(BigInteger.valueOf(-7390L))); + org.junit.Assert.assertTrue("'" + msg.biases[60].value + "' != '" + -7390 + "'", value.equals(BigInteger.valueOf( -7390L ) ) ); } else { value = value.longValue(); expected = -7390L; @@ -1511,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.biases[61].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[61].code + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.biases[61].code + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -1521,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.biases[61].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[61].value + "' != '" + 4676 + "'", - value.equals(BigInteger.valueOf(4676L))); + org.junit.Assert.assertTrue("'" + msg.biases[61].value + "' != '" + 4676 + "'", value.equals(BigInteger.valueOf( 4676L ) ) ); } else { value = value.longValue(); expected = 4676L; @@ -1531,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.biases[62].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[62].code + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.biases[62].code + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -1541,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.biases[62].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[62].value + "' != '" + 23007 + "'", - value.equals(BigInteger.valueOf(23007L))); + org.junit.Assert.assertTrue("'" + msg.biases[62].value + "' != '" + 23007 + "'", value.equals(BigInteger.valueOf( 23007L ) ) ); } else { value = value.longValue(); expected = 23007L; @@ -1551,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.biases[63].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[63].code + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.biases[63].code + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -1561,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.biases[63].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[63].value + "' != '" + 13046 + "'", - value.equals(BigInteger.valueOf(13046L))); + org.junit.Assert.assertTrue("'" + msg.biases[63].value + "' != '" + 13046 + "'", value.equals(BigInteger.valueOf( 13046L ) ) ); } else { value = value.longValue(); expected = 13046L; @@ -1571,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.biases[64].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[64].code + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.biases[64].code + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -1581,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.biases[64].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[64].value + "' != '" + 2651 + "'", - value.equals(BigInteger.valueOf(2651L))); + org.junit.Assert.assertTrue("'" + msg.biases[64].value + "' != '" + 2651 + "'", value.equals(BigInteger.valueOf( 2651L ) ) ); } else { value = value.longValue(); expected = 2651L; @@ -1591,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.biases[65].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[65].code + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.biases[65].code + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -1601,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.biases[65].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[65].value + "' != '" + 30282 + "'", - value.equals(BigInteger.valueOf(30282L))); + org.junit.Assert.assertTrue("'" + msg.biases[65].value + "' != '" + 30282 + "'", value.equals(BigInteger.valueOf( 30282L ) ) ); } else { value = value.longValue(); expected = 30282L; @@ -1611,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.biases[66].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[66].code + "' != '" + 110 + "'", - value.equals(BigInteger.valueOf(110L))); + org.junit.Assert.assertTrue("'" + msg.biases[66].code + "' != '" + 110 + "'", value.equals(BigInteger.valueOf( 110L ) ) ); } else { value = value.longValue(); expected = 110L; @@ -1621,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.biases[66].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[66].value + "' != '" + -22492 + "'", - value.equals(BigInteger.valueOf(-22492L))); + org.junit.Assert.assertTrue("'" + msg.biases[66].value + "' != '" + -22492 + "'", value.equals(BigInteger.valueOf( -22492L ) ) ); } else { value = value.longValue(); expected = -22492L; @@ -1631,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.biases[67].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[67].code + "' != '" + 247 + "'", - value.equals(BigInteger.valueOf(247L))); + org.junit.Assert.assertTrue("'" + msg.biases[67].code + "' != '" + 247 + "'", value.equals(BigInteger.valueOf( 247L ) ) ); } else { value = value.longValue(); expected = 247L; @@ -1641,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.biases[67].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[67].value + "' != '" + 19872 + "'", - value.equals(BigInteger.valueOf(19872L))); + org.junit.Assert.assertTrue("'" + msg.biases[67].value + "' != '" + 19872 + "'", value.equals(BigInteger.valueOf( 19872L ) ) ); } else { value = value.longValue(); expected = 19872L; @@ -1651,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.biases[68].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[68].code + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.biases[68].code + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -1661,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.biases[68].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[68].value + "' != '" + -19827 + "'", - value.equals(BigInteger.valueOf(-19827L))); + org.junit.Assert.assertTrue("'" + msg.biases[68].value + "' != '" + -19827 + "'", value.equals(BigInteger.valueOf( -19827L ) ) ); } else { value = value.longValue(); expected = -19827L; @@ -1671,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.biases[69].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[69].code + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.biases[69].code + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -1681,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.biases[69].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[69].value + "' != '" + 30911 + "'", - value.equals(BigInteger.valueOf(30911L))); + org.junit.Assert.assertTrue("'" + msg.biases[69].value + "' != '" + 30911 + "'", value.equals(BigInteger.valueOf( 30911L ) ) ); } else { value = value.longValue(); expected = 30911L; @@ -1691,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.biases[70].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[70].code + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.biases[70].code + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -1701,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.biases[70].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[70].value + "' != '" + 23488 + "'", - value.equals(BigInteger.valueOf(23488L))); + org.junit.Assert.assertTrue("'" + msg.biases[70].value + "' != '" + 23488 + "'", value.equals(BigInteger.valueOf( 23488L ) ) ); } else { value = value.longValue(); expected = 23488L; @@ -1711,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.biases[71].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[71].code + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.biases[71].code + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -1721,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.biases[71].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[71].value + "' != '" + -7679 + "'", - value.equals(BigInteger.valueOf(-7679L))); + org.junit.Assert.assertTrue("'" + msg.biases[71].value + "' != '" + -7679 + "'", value.equals(BigInteger.valueOf( -7679L ) ) ); } else { value = value.longValue(); expected = -7679L; @@ -1731,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.biases[72].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[72].code + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.biases[72].code + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -1741,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.biases[72].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[72].value + "' != '" + -28073 + "'", - value.equals(BigInteger.valueOf(-28073L))); + org.junit.Assert.assertTrue("'" + msg.biases[72].value + "' != '" + -28073 + "'", value.equals(BigInteger.valueOf( -28073L ) ) ); } else { value = value.longValue(); expected = -28073L; @@ -1751,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.biases[73].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[73].code + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.biases[73].code + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -1761,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.biases[73].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[73].value + "' != '" + 25838 + "'", - value.equals(BigInteger.valueOf(25838L))); + org.junit.Assert.assertTrue("'" + msg.biases[73].value + "' != '" + 25838 + "'", value.equals(BigInteger.valueOf( 25838L ) ) ); } else { value = value.longValue(); expected = 25838L; @@ -1771,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.biases[74].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[74].code + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.biases[74].code + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -1781,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.biases[74].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[74].value + "' != '" + -7299 + "'", - value.equals(BigInteger.valueOf(-7299L))); + org.junit.Assert.assertTrue("'" + msg.biases[74].value + "' != '" + -7299 + "'", value.equals(BigInteger.valueOf( -7299L ) ) ); } else { value = value.longValue(); expected = -7299L; @@ -1791,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.biases[75].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[75].code + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.biases[75].code + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -1801,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.biases[75].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[75].value + "' != '" + -18328 + "'", - value.equals(BigInteger.valueOf(-18328L))); + org.junit.Assert.assertTrue("'" + msg.biases[75].value + "' != '" + -18328 + "'", value.equals(BigInteger.valueOf( -18328L ) ) ); } else { value = value.longValue(); expected = -18328L; @@ -1811,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.biases[76].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[76].code + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.biases[76].code + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -1821,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.biases[76].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[76].value + "' != '" + 23097 + "'", - value.equals(BigInteger.valueOf(23097L))); + org.junit.Assert.assertTrue("'" + msg.biases[76].value + "' != '" + 23097 + "'", value.equals(BigInteger.valueOf( 23097L ) ) ); } else { value = value.longValue(); expected = 23097L; @@ -1831,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.biases[77].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[77].code + "' != '" + 79 + "'", - value.equals(BigInteger.valueOf(79L))); + org.junit.Assert.assertTrue("'" + msg.biases[77].code + "' != '" + 79 + "'", value.equals(BigInteger.valueOf( 79L ) ) ); } else { value = value.longValue(); expected = 79L; @@ -1841,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.biases[77].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[77].value + "' != '" + -25579 + "'", - value.equals(BigInteger.valueOf(-25579L))); + org.junit.Assert.assertTrue("'" + msg.biases[77].value + "' != '" + -25579 + "'", value.equals(BigInteger.valueOf( -25579L ) ) ); } else { value = value.longValue(); expected = -25579L; @@ -1851,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.biases[78].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[78].code + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.biases[78].code + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -1861,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.biases[78].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[78].value + "' != '" + 15441 + "'", - value.equals(BigInteger.valueOf(15441L))); + org.junit.Assert.assertTrue("'" + msg.biases[78].value + "' != '" + 15441 + "'", value.equals(BigInteger.valueOf( 15441L ) ) ); } else { value = value.longValue(); expected = 15441L; @@ -1871,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.biases[79].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[79].code + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.biases[79].code + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -1881,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.biases[79].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[79].value + "' != '" + 15530 + "'", - value.equals(BigInteger.valueOf(15530L))); + org.junit.Assert.assertTrue("'" + msg.biases[79].value + "' != '" + 15530 + "'", value.equals(BigInteger.valueOf( 15530L ) ) ); } else { value = value.longValue(); expected = 15530L; @@ -1891,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.biases[80].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[80].code + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.biases[80].code + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -1901,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.biases[80].value; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[80].value + "' != '" + 3495 + "'", - value.equals(BigInteger.valueOf(3495L))); + org.junit.Assert.assertTrue("'" + msg.biases[80].value + "' != '" + 3495 + "'", value.equals(BigInteger.valueOf( 3495L ) ) ); } else { value = value.longValue(); expected = 3495L; @@ -1911,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.iod_ssr; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.iod_ssr + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.iod_ssr + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -1921,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 241 + "'", - value.equals(BigInteger.valueOf(241L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 241 + "'", value.equals(BigInteger.valueOf( 241L ) ) ); } else { value = value.longValue(); expected = 241L; @@ -1931,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -1941,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time.tow + "' != '" + 387144400 + "'", - value.equals(BigInteger.valueOf(387144400L))); + org.junit.Assert.assertTrue("'" + msg.time.tow + "' != '" + 387144400 + "'", value.equals(BigInteger.valueOf( 387144400L ) ) ); } else { value = value.longValue(); expected = 387144400L; @@ -1951,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time.wn + "' != '" + 16905 + "'", - value.equals(BigInteger.valueOf(16905L))); + org.junit.Assert.assertTrue("'" + msg.time.wn + "' != '" + 16905 + "'", value.equals(BigInteger.valueOf( 16905L ) ) ); } else { value = value.longValue(); expected = 16905L; @@ -1961,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.update_interval + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.update_interval + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest.java b/java/test/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest.java index eb7d73ea4..28e65842f 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodePhaseBiasesBounds.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrCodePhaseBiasesBounds.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrCodePhaseBiasesBounds; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest { @@ -30,23 +34,15 @@ public class auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrCodePhaseBiasesBoundsTest.test1"); - byte[] payload = - new byte[] { - (byte) 180, (byte) 0, (byte) 0, (byte) 0, (byte) 3, (byte) 0, (byte) 1, - (byte) 2, (byte) 1, (byte) 14, (byte) 15, (byte) 1, (byte) 3, (byte) 0, - (byte) 3, (byte) 39, (byte) 1, (byte) 39, (byte) 1, (byte) 1, (byte) 3, - (byte) 39, (byte) 1, (byte) 39, (byte) 1, (byte) 1, (byte) 1, (byte) 39, - (byte) 1, (byte) 39, (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x05EC, payload); - MsgSsrCodePhaseBiasesBounds msg = new MsgSsrCodePhaseBiasesBounds(sbp); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)1,(byte)2,(byte)1,(byte)14,(byte)15,(byte)1,(byte)3,(byte)0,(byte)3,(byte)39,(byte)1,(byte)39,(byte)1,(byte)1,(byte)3,(byte)39,(byte)1,(byte)39,(byte)1,(byte)1,(byte)1,(byte)39,(byte)1,(byte)39,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x05EC, payload ); + MsgSsrCodePhaseBiasesBounds msg = new MsgSsrCodePhaseBiasesBounds( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.const_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.const_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.const_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -54,9 +50,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -64,9 +58,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -74,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.sol_id + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.header.sol_id + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -84,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.header.time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -94,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -104,9 +90,7 @@ public void test1() throws Throwable { } value = msg.header.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.update_interval + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.header.update_interval + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -114,9 +98,7 @@ public void test1() throws Throwable { } value = msg.n_sats_signals; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats_signals + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.n_sats_signals + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -124,9 +106,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[0].code_bias_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[0].code_bias_bound_mu + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[0].code_bias_bound_mu + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -134,9 +114,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[0].code_bias_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[0].code_bias_bound_sig + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[0].code_bias_bound_sig + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -144,9 +122,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[0].phase_bias_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[0].phase_bias_bound_mu + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[0].phase_bias_bound_mu + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -154,9 +130,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[0].phase_bias_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[0].phase_bias_bound_sig + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[0].phase_bias_bound_sig + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -164,9 +138,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[0].sat_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[0].sat_id + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[0].sat_id + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -174,9 +146,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[0].signal_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[0].signal_id + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[0].signal_id + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -184,9 +154,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[1].code_bias_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[1].code_bias_bound_mu + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[1].code_bias_bound_mu + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -194,9 +162,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[1].code_bias_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[1].code_bias_bound_sig + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[1].code_bias_bound_sig + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -204,9 +170,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[1].phase_bias_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[1].phase_bias_bound_mu + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[1].phase_bias_bound_mu + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -214,9 +178,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[1].phase_bias_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[1].phase_bias_bound_sig + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[1].phase_bias_bound_sig + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -224,9 +186,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[1].sat_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[1].sat_id + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[1].sat_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -234,9 +194,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[1].signal_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[1].signal_id + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[1].signal_id + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -244,9 +202,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[2].code_bias_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[2].code_bias_bound_mu + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[2].code_bias_bound_mu + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -254,9 +210,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[2].code_bias_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[2].code_bias_bound_sig + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[2].code_bias_bound_sig + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -264,9 +218,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[2].phase_bias_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[2].phase_bias_bound_mu + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[2].phase_bias_bound_mu + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -274,9 +226,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[2].phase_bias_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[2].phase_bias_bound_sig + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[2].phase_bias_bound_sig + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -284,9 +234,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[2].sat_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[2].sat_id + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[2].sat_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -294,9 +242,7 @@ public void test1() throws Throwable { } value = msg.satellites_signals[2].signal_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.satellites_signals[2].signal_id + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.satellites_signals[2].signal_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -304,8 +250,7 @@ public void test1() throws Throwable { } value = msg.ssr_iod; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ssr_iod + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.ssr_iod + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrGridDefinitionDepATest.java b/java/test/auto_check_sbp_ssr_MsgSsrGridDefinitionDepATest.java index 96ba4fcd1..7c30f9e09 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrGridDefinitionDepATest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrGridDefinitionDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGridDefinitionDepA.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGridDefinitionDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrGridDefinitionDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrGridDefinitionDepATest { @@ -30,274 +34,15 @@ public class auto_check_sbp_ssr_MsgSsrGridDefinitionDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrGridDefinitionDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 11, - (byte) 84, - (byte) 171, - (byte) 229, - (byte) 132, - (byte) 143, - (byte) 46, - (byte) 204, - (byte) 52, - (byte) 92, - (byte) 104, - (byte) 25, - (byte) 204, - (byte) 182, - (byte) 22, - (byte) 98, - (byte) 203, - (byte) 123, - (byte) 211, - (byte) 38, - (byte) 13, - (byte) 253, - (byte) 129, - (byte) 173, - (byte) 171, - (byte) 235, - (byte) 253, - (byte) 26, - (byte) 203, - (byte) 3, - (byte) 120, - (byte) 126, - (byte) 42, - (byte) 44, - (byte) 39, - (byte) 87, - (byte) 69, - (byte) 154, - (byte) 13, - (byte) 28, - (byte) 179, - (byte) 32, - (byte) 47, - (byte) 36, - (byte) 195, - (byte) 39, - (byte) 198, - (byte) 134, - (byte) 235, - (byte) 134, - (byte) 57, - (byte) 120, - (byte) 243, - (byte) 151, - (byte) 35, - (byte) 17, - (byte) 201, - (byte) 211, - (byte) 125, - (byte) 117, - (byte) 164, - (byte) 142, - (byte) 101, - (byte) 239, - (byte) 144, - (byte) 158, - (byte) 239, - (byte) 90, - (byte) 56, - (byte) 71, - (byte) 120, - (byte) 67, - (byte) 221, - (byte) 114, - (byte) 10, - (byte) 190, - (byte) 4, - (byte) 230, - (byte) 164, - (byte) 171, - (byte) 78, - (byte) 185, - (byte) 90, - (byte) 46, - (byte) 177, - (byte) 82, - (byte) 228, - (byte) 123, - (byte) 222, - (byte) 227, - (byte) 145, - (byte) 195, - (byte) 219, - (byte) 27, - (byte) 56, - (byte) 227, - (byte) 246, - (byte) 215, - (byte) 144, - (byte) 158, - (byte) 31, - (byte) 214, - (byte) 241, - (byte) 254, - (byte) 200, - (byte) 86, - (byte) 142, - (byte) 89, - (byte) 12, - (byte) 121, - (byte) 29, - (byte) 124, - (byte) 9, - (byte) 19, - (byte) 153, - (byte) 44, - (byte) 35, - (byte) 126, - (byte) 14, - (byte) 217, - (byte) 65, - (byte) 116, - (byte) 26, - (byte) 139, - (byte) 122, - (byte) 114, - (byte) 90, - (byte) 124, - (byte) 81, - (byte) 0, - (byte) 186, - (byte) 246, - (byte) 46, - (byte) 98, - (byte) 179, - (byte) 243, - (byte) 198, - (byte) 217, - (byte) 36, - (byte) 30, - (byte) 202, - (byte) 12, - (byte) 135, - (byte) 61, - (byte) 42, - (byte) 150, - (byte) 221, - (byte) 102, - (byte) 83, - (byte) 179, - (byte) 43, - (byte) 252, - (byte) 81, - (byte) 62, - (byte) 126, - (byte) 204, - (byte) 195, - (byte) 238, - (byte) 18, - (byte) 128, - (byte) 193, - (byte) 53, - (byte) 94, - (byte) 99, - (byte) 63, - (byte) 182, - (byte) 2, - (byte) 186, - (byte) 220, - (byte) 77, - (byte) 186, - (byte) 224, - (byte) 220, - (byte) 13, - (byte) 212, - (byte) 182, - (byte) 88, - (byte) 15, - (byte) 151, - (byte) 5, - (byte) 93, - (byte) 251, - (byte) 164, - (byte) 18, - (byte) 228, - (byte) 168, - (byte) 226, - (byte) 195, - (byte) 44, - (byte) 170, - (byte) 145, - (byte) 36, - (byte) 58, - (byte) 96, - (byte) 107, - (byte) 144, - (byte) 11, - (byte) 228, - (byte) 12, - (byte) 163, - (byte) 238, - (byte) 247, - (byte) 159, - (byte) 189, - (byte) 1, - (byte) 115, - (byte) 65, - (byte) 202, - (byte) 121, - (byte) 47, - (byte) 193, - (byte) 11, - (byte) 96, - (byte) 93, - (byte) 72, - (byte) 81, - (byte) 207, - (byte) 121, - (byte) 19, - (byte) 151, - (byte) 136, - (byte) 233, - (byte) 51, - (byte) 133, - (byte) 195, - (byte) 77, - (byte) 44, - (byte) 147, - (byte) 206, - (byte) 120, - (byte) 252, - (byte) 77, - (byte) 212, - (byte) 68, - (byte) 60, - (byte) 206, - (byte) 106, - (byte) 207, - (byte) 243, - (byte) 158, - (byte) 94, - (byte) 6, - (byte) 3, - (byte) 205, - (byte) 92, - (byte) 84, - (byte) 2, - (byte) 220, - (byte) 50, - (byte) 61, - (byte) 38, - (byte) 141, - (byte) 117, - (byte) 108, - (byte) 101, - }; - SBPMessage sbp = new SBPMessage(0xf7b5, 0x5f5, payload); - MsgSsrGridDefinitionDepA msg = new MsgSsrGridDefinitionDepA(sbp); + byte[] payload = new byte[] {(byte)11,(byte)84,(byte)171,(byte)229,(byte)132,(byte)143,(byte)46,(byte)204,(byte)52,(byte)92,(byte)104,(byte)25,(byte)204,(byte)182,(byte)22,(byte)98,(byte)203,(byte)123,(byte)211,(byte)38,(byte)13,(byte)253,(byte)129,(byte)173,(byte)171,(byte)235,(byte)253,(byte)26,(byte)203,(byte)3,(byte)120,(byte)126,(byte)42,(byte)44,(byte)39,(byte)87,(byte)69,(byte)154,(byte)13,(byte)28,(byte)179,(byte)32,(byte)47,(byte)36,(byte)195,(byte)39,(byte)198,(byte)134,(byte)235,(byte)134,(byte)57,(byte)120,(byte)243,(byte)151,(byte)35,(byte)17,(byte)201,(byte)211,(byte)125,(byte)117,(byte)164,(byte)142,(byte)101,(byte)239,(byte)144,(byte)158,(byte)239,(byte)90,(byte)56,(byte)71,(byte)120,(byte)67,(byte)221,(byte)114,(byte)10,(byte)190,(byte)4,(byte)230,(byte)164,(byte)171,(byte)78,(byte)185,(byte)90,(byte)46,(byte)177,(byte)82,(byte)228,(byte)123,(byte)222,(byte)227,(byte)145,(byte)195,(byte)219,(byte)27,(byte)56,(byte)227,(byte)246,(byte)215,(byte)144,(byte)158,(byte)31,(byte)214,(byte)241,(byte)254,(byte)200,(byte)86,(byte)142,(byte)89,(byte)12,(byte)121,(byte)29,(byte)124,(byte)9,(byte)19,(byte)153,(byte)44,(byte)35,(byte)126,(byte)14,(byte)217,(byte)65,(byte)116,(byte)26,(byte)139,(byte)122,(byte)114,(byte)90,(byte)124,(byte)81,(byte)0,(byte)186,(byte)246,(byte)46,(byte)98,(byte)179,(byte)243,(byte)198,(byte)217,(byte)36,(byte)30,(byte)202,(byte)12,(byte)135,(byte)61,(byte)42,(byte)150,(byte)221,(byte)102,(byte)83,(byte)179,(byte)43,(byte)252,(byte)81,(byte)62,(byte)126,(byte)204,(byte)195,(byte)238,(byte)18,(byte)128,(byte)193,(byte)53,(byte)94,(byte)99,(byte)63,(byte)182,(byte)2,(byte)186,(byte)220,(byte)77,(byte)186,(byte)224,(byte)220,(byte)13,(byte)212,(byte)182,(byte)88,(byte)15,(byte)151,(byte)5,(byte)93,(byte)251,(byte)164,(byte)18,(byte)228,(byte)168,(byte)226,(byte)195,(byte)44,(byte)170,(byte)145,(byte)36,(byte)58,(byte)96,(byte)107,(byte)144,(byte)11,(byte)228,(byte)12,(byte)163,(byte)238,(byte)247,(byte)159,(byte)189,(byte)1,(byte)115,(byte)65,(byte)202,(byte)121,(byte)47,(byte)193,(byte)11,(byte)96,(byte)93,(byte)72,(byte)81,(byte)207,(byte)121,(byte)19,(byte)151,(byte)136,(byte)233,(byte)51,(byte)133,(byte)195,(byte)77,(byte)44,(byte)147,(byte)206,(byte)120,(byte)252,(byte)77,(byte)212,(byte)68,(byte)60,(byte)206,(byte)106,(byte)207,(byte)243,(byte)158,(byte)94,(byte)6,(byte)3,(byte)205,(byte)92,(byte)84,(byte)2,(byte)220,(byte)50,(byte)61,(byte)38,(byte)141,(byte)117,(byte)108,(byte)101, }; + SBPMessage sbp = new SBPMessage( 0xf7b5, 0x5f5, payload ); + MsgSsrGridDefinitionDepA msg = new MsgSsrGridDefinitionDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.header.area_width; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.area_width + "' != '" + 43860 + "'", - value.equals(BigInteger.valueOf(43860L))); + org.junit.Assert.assertTrue("'" + msg.header.area_width + "' != '" + 43860 + "'", value.equals(BigInteger.valueOf( 43860L ) ) ); } else { value = value.longValue(); expected = 43860L; @@ -305,9 +50,7 @@ public void test1() throws Throwable { } value = msg.header.lat_nw_corner_enc; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.lat_nw_corner_enc + "' != '" + 34021 + "'", - value.equals(BigInteger.valueOf(34021L))); + org.junit.Assert.assertTrue("'" + msg.header.lat_nw_corner_enc + "' != '" + 34021 + "'", value.equals(BigInteger.valueOf( 34021L ) ) ); } else { value = value.longValue(); expected = 34021L; @@ -315,9 +58,7 @@ public void test1() throws Throwable { } value = msg.header.lon_nw_corner_enc; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.lon_nw_corner_enc + "' != '" + 11919 + "'", - value.equals(BigInteger.valueOf(11919L))); + org.junit.Assert.assertTrue("'" + msg.header.lon_nw_corner_enc + "' != '" + 11919 + "'", value.equals(BigInteger.valueOf( 11919L ) ) ); } else { value = value.longValue(); expected = 11919L; @@ -325,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 204 + "'", - value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -335,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.region_size_inverse; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.region_size_inverse + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.header.region_size_inverse + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -345,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -355,9 +90,7 @@ public void test1() throws Throwable { } value = msg.rle_list[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[0] + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[0] + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -365,9 +98,7 @@ public void test1() throws Throwable { } value = msg.rle_list[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[1] + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[1] + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -375,9 +106,7 @@ public void test1() throws Throwable { } value = msg.rle_list[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[2] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[2] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -385,9 +114,7 @@ public void test1() throws Throwable { } value = msg.rle_list[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[3] + "' != '" + 204 + "'", - value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[3] + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -395,9 +122,7 @@ public void test1() throws Throwable { } value = msg.rle_list[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[4] + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[4] + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -405,9 +130,7 @@ public void test1() throws Throwable { } value = msg.rle_list[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[5] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[5] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -415,9 +138,7 @@ public void test1() throws Throwable { } value = msg.rle_list[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[6] + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[6] + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -425,9 +146,7 @@ public void test1() throws Throwable { } value = msg.rle_list[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[7] + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[7] + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -435,9 +154,7 @@ public void test1() throws Throwable { } value = msg.rle_list[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[8] + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[8] + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -445,9 +162,7 @@ public void test1() throws Throwable { } value = msg.rle_list[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[9] + "' != '" + 211 + "'", - value.equals(BigInteger.valueOf(211L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[9] + "' != '" + 211 + "'", value.equals(BigInteger.valueOf( 211L ) ) ); } else { value = value.longValue(); expected = 211L; @@ -455,9 +170,7 @@ public void test1() throws Throwable { } value = msg.rle_list[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[10] + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[10] + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -465,9 +178,7 @@ public void test1() throws Throwable { } value = msg.rle_list[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[11] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[11] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -475,9 +186,7 @@ public void test1() throws Throwable { } value = msg.rle_list[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[12] + "' != '" + 253 + "'", - value.equals(BigInteger.valueOf(253L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[12] + "' != '" + 253 + "'", value.equals(BigInteger.valueOf( 253L ) ) ); } else { value = value.longValue(); expected = 253L; @@ -485,9 +194,7 @@ public void test1() throws Throwable { } value = msg.rle_list[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[13] + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[13] + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -495,9 +202,7 @@ public void test1() throws Throwable { } value = msg.rle_list[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[14] + "' != '" + 173 + "'", - value.equals(BigInteger.valueOf(173L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[14] + "' != '" + 173 + "'", value.equals(BigInteger.valueOf( 173L ) ) ); } else { value = value.longValue(); expected = 173L; @@ -505,9 +210,7 @@ public void test1() throws Throwable { } value = msg.rle_list[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[15] + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[15] + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -515,9 +218,7 @@ public void test1() throws Throwable { } value = msg.rle_list[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[16] + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[16] + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -525,9 +226,7 @@ public void test1() throws Throwable { } value = msg.rle_list[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[17] + "' != '" + 253 + "'", - value.equals(BigInteger.valueOf(253L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[17] + "' != '" + 253 + "'", value.equals(BigInteger.valueOf( 253L ) ) ); } else { value = value.longValue(); expected = 253L; @@ -535,9 +234,7 @@ public void test1() throws Throwable { } value = msg.rle_list[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[18] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[18] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -545,9 +242,7 @@ public void test1() throws Throwable { } value = msg.rle_list[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[19] + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[19] + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -555,9 +250,7 @@ public void test1() throws Throwable { } value = msg.rle_list[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[20] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[20] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -565,9 +258,7 @@ public void test1() throws Throwable { } value = msg.rle_list[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[21] + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[21] + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -575,9 +266,7 @@ public void test1() throws Throwable { } value = msg.rle_list[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[22] + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[22] + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -585,9 +274,7 @@ public void test1() throws Throwable { } value = msg.rle_list[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[23] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[23] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -595,9 +282,7 @@ public void test1() throws Throwable { } value = msg.rle_list[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[24] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[24] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -605,9 +290,7 @@ public void test1() throws Throwable { } value = msg.rle_list[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[25] + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[25] + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -615,9 +298,7 @@ public void test1() throws Throwable { } value = msg.rle_list[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[26] + "' != '" + 87 + "'", - value.equals(BigInteger.valueOf(87L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[26] + "' != '" + 87 + "'", value.equals(BigInteger.valueOf( 87L ) ) ); } else { value = value.longValue(); expected = 87L; @@ -625,9 +306,7 @@ public void test1() throws Throwable { } value = msg.rle_list[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[27] + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[27] + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -635,9 +314,7 @@ public void test1() throws Throwable { } value = msg.rle_list[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[28] + "' != '" + 154 + "'", - value.equals(BigInteger.valueOf(154L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[28] + "' != '" + 154 + "'", value.equals(BigInteger.valueOf( 154L ) ) ); } else { value = value.longValue(); expected = 154L; @@ -645,9 +322,7 @@ public void test1() throws Throwable { } value = msg.rle_list[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[29] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[29] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -655,9 +330,7 @@ public void test1() throws Throwable { } value = msg.rle_list[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[30] + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[30] + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -665,9 +338,7 @@ public void test1() throws Throwable { } value = msg.rle_list[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[31] + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[31] + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -675,9 +346,7 @@ public void test1() throws Throwable { } value = msg.rle_list[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[32] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[32] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -685,9 +354,7 @@ public void test1() throws Throwable { } value = msg.rle_list[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[33] + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[33] + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -695,9 +362,7 @@ public void test1() throws Throwable { } value = msg.rle_list[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[34] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[34] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -705,9 +370,7 @@ public void test1() throws Throwable { } value = msg.rle_list[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[35] + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[35] + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -715,9 +378,7 @@ public void test1() throws Throwable { } value = msg.rle_list[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[36] + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[36] + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -725,9 +386,7 @@ public void test1() throws Throwable { } value = msg.rle_list[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[37] + "' != '" + 198 + "'", - value.equals(BigInteger.valueOf(198L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[37] + "' != '" + 198 + "'", value.equals(BigInteger.valueOf( 198L ) ) ); } else { value = value.longValue(); expected = 198L; @@ -735,9 +394,7 @@ public void test1() throws Throwable { } value = msg.rle_list[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[38] + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[38] + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -745,9 +402,7 @@ public void test1() throws Throwable { } value = msg.rle_list[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[39] + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[39] + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -755,9 +410,7 @@ public void test1() throws Throwable { } value = msg.rle_list[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[40] + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[40] + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -765,9 +418,7 @@ public void test1() throws Throwable { } value = msg.rle_list[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[41] + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[41] + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -775,9 +426,7 @@ public void test1() throws Throwable { } value = msg.rle_list[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[42] + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[42] + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -785,9 +434,7 @@ public void test1() throws Throwable { } value = msg.rle_list[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[43] + "' != '" + 243 + "'", - value.equals(BigInteger.valueOf(243L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[43] + "' != '" + 243 + "'", value.equals(BigInteger.valueOf( 243L ) ) ); } else { value = value.longValue(); expected = 243L; @@ -795,9 +442,7 @@ public void test1() throws Throwable { } value = msg.rle_list[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[44] + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[44] + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -805,9 +450,7 @@ public void test1() throws Throwable { } value = msg.rle_list[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[45] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[45] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -815,9 +458,7 @@ public void test1() throws Throwable { } value = msg.rle_list[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[46] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[46] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -825,9 +466,7 @@ public void test1() throws Throwable { } value = msg.rle_list[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[47] + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[47] + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -835,9 +474,7 @@ public void test1() throws Throwable { } value = msg.rle_list[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[48] + "' != '" + 211 + "'", - value.equals(BigInteger.valueOf(211L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[48] + "' != '" + 211 + "'", value.equals(BigInteger.valueOf( 211L ) ) ); } else { value = value.longValue(); expected = 211L; @@ -845,9 +482,7 @@ public void test1() throws Throwable { } value = msg.rle_list[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[49] + "' != '" + 125 + "'", - value.equals(BigInteger.valueOf(125L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[49] + "' != '" + 125 + "'", value.equals(BigInteger.valueOf( 125L ) ) ); } else { value = value.longValue(); expected = 125L; @@ -855,9 +490,7 @@ public void test1() throws Throwable { } value = msg.rle_list[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[50] + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[50] + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -865,9 +498,7 @@ public void test1() throws Throwable { } value = msg.rle_list[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[51] + "' != '" + 164 + "'", - value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[51] + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -875,9 +506,7 @@ public void test1() throws Throwable { } value = msg.rle_list[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[52] + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[52] + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -885,9 +514,7 @@ public void test1() throws Throwable { } value = msg.rle_list[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[53] + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[53] + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -895,9 +522,7 @@ public void test1() throws Throwable { } value = msg.rle_list[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[54] + "' != '" + 239 + "'", - value.equals(BigInteger.valueOf(239L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[54] + "' != '" + 239 + "'", value.equals(BigInteger.valueOf( 239L ) ) ); } else { value = value.longValue(); expected = 239L; @@ -905,9 +530,7 @@ public void test1() throws Throwable { } value = msg.rle_list[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[55] + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[55] + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -915,9 +538,7 @@ public void test1() throws Throwable { } value = msg.rle_list[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[56] + "' != '" + 158 + "'", - value.equals(BigInteger.valueOf(158L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[56] + "' != '" + 158 + "'", value.equals(BigInteger.valueOf( 158L ) ) ); } else { value = value.longValue(); expected = 158L; @@ -925,9 +546,7 @@ public void test1() throws Throwable { } value = msg.rle_list[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[57] + "' != '" + 239 + "'", - value.equals(BigInteger.valueOf(239L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[57] + "' != '" + 239 + "'", value.equals(BigInteger.valueOf( 239L ) ) ); } else { value = value.longValue(); expected = 239L; @@ -935,9 +554,7 @@ public void test1() throws Throwable { } value = msg.rle_list[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[58] + "' != '" + 90 + "'", - value.equals(BigInteger.valueOf(90L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[58] + "' != '" + 90 + "'", value.equals(BigInteger.valueOf( 90L ) ) ); } else { value = value.longValue(); expected = 90L; @@ -945,9 +562,7 @@ public void test1() throws Throwable { } value = msg.rle_list[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[59] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[59] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -955,9 +570,7 @@ public void test1() throws Throwable { } value = msg.rle_list[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[60] + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[60] + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -965,9 +578,7 @@ public void test1() throws Throwable { } value = msg.rle_list[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[61] + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[61] + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -975,9 +586,7 @@ public void test1() throws Throwable { } value = msg.rle_list[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[62] + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[62] + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -985,9 +594,7 @@ public void test1() throws Throwable { } value = msg.rle_list[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[63] + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[63] + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -995,9 +602,7 @@ public void test1() throws Throwable { } value = msg.rle_list[64]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[64] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[64] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -1005,9 +610,7 @@ public void test1() throws Throwable { } value = msg.rle_list[65]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[65] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[65] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -1015,9 +618,7 @@ public void test1() throws Throwable { } value = msg.rle_list[66]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[66] + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[66] + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -1025,9 +626,7 @@ public void test1() throws Throwable { } value = msg.rle_list[67]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[67] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[67] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1035,9 +634,7 @@ public void test1() throws Throwable { } value = msg.rle_list[68]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[68] + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[68] + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1045,9 +642,7 @@ public void test1() throws Throwable { } value = msg.rle_list[69]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[69] + "' != '" + 164 + "'", - value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[69] + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -1055,9 +650,7 @@ public void test1() throws Throwable { } value = msg.rle_list[70]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[70] + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[70] + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -1065,9 +658,7 @@ public void test1() throws Throwable { } value = msg.rle_list[71]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[71] + "' != '" + 78 + "'", - value.equals(BigInteger.valueOf(78L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[71] + "' != '" + 78 + "'", value.equals(BigInteger.valueOf( 78L ) ) ); } else { value = value.longValue(); expected = 78L; @@ -1075,9 +666,7 @@ public void test1() throws Throwable { } value = msg.rle_list[72]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[72] + "' != '" + 185 + "'", - value.equals(BigInteger.valueOf(185L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[72] + "' != '" + 185 + "'", value.equals(BigInteger.valueOf( 185L ) ) ); } else { value = value.longValue(); expected = 185L; @@ -1085,9 +674,7 @@ public void test1() throws Throwable { } value = msg.rle_list[73]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[73] + "' != '" + 90 + "'", - value.equals(BigInteger.valueOf(90L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[73] + "' != '" + 90 + "'", value.equals(BigInteger.valueOf( 90L ) ) ); } else { value = value.longValue(); expected = 90L; @@ -1095,9 +682,7 @@ public void test1() throws Throwable { } value = msg.rle_list[74]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[74] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[74] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -1105,9 +690,7 @@ public void test1() throws Throwable { } value = msg.rle_list[75]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[75] + "' != '" + 177 + "'", - value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[75] + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -1115,9 +698,7 @@ public void test1() throws Throwable { } value = msg.rle_list[76]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[76] + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[76] + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -1125,9 +706,7 @@ public void test1() throws Throwable { } value = msg.rle_list[77]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[77] + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[77] + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -1135,9 +714,7 @@ public void test1() throws Throwable { } value = msg.rle_list[78]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[78] + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[78] + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -1145,9 +722,7 @@ public void test1() throws Throwable { } value = msg.rle_list[79]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[79] + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[79] + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -1155,9 +730,7 @@ public void test1() throws Throwable { } value = msg.rle_list[80]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[80] + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[80] + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1165,9 +738,7 @@ public void test1() throws Throwable { } value = msg.rle_list[81]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[81] + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[81] + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -1175,9 +746,7 @@ public void test1() throws Throwable { } value = msg.rle_list[82]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[82] + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[82] + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -1185,9 +754,7 @@ public void test1() throws Throwable { } value = msg.rle_list[83]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[83] + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[83] + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -1195,9 +762,7 @@ public void test1() throws Throwable { } value = msg.rle_list[84]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[84] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[84] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -1205,9 +770,7 @@ public void test1() throws Throwable { } value = msg.rle_list[85]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[85] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[85] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -1215,9 +778,7 @@ public void test1() throws Throwable { } value = msg.rle_list[86]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[86] + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[86] + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1225,9 +786,7 @@ public void test1() throws Throwable { } value = msg.rle_list[87]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[87] + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[87] + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -1235,9 +794,7 @@ public void test1() throws Throwable { } value = msg.rle_list[88]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[88] + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[88] + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -1245,9 +802,7 @@ public void test1() throws Throwable { } value = msg.rle_list[89]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[89] + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[89] + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -1255,9 +810,7 @@ public void test1() throws Throwable { } value = msg.rle_list[90]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[90] + "' != '" + 158 + "'", - value.equals(BigInteger.valueOf(158L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[90] + "' != '" + 158 + "'", value.equals(BigInteger.valueOf( 158L ) ) ); } else { value = value.longValue(); expected = 158L; @@ -1265,9 +818,7 @@ public void test1() throws Throwable { } value = msg.rle_list[91]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[91] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[91] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -1275,9 +826,7 @@ public void test1() throws Throwable { } value = msg.rle_list[92]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[92] + "' != '" + 214 + "'", - value.equals(BigInteger.valueOf(214L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[92] + "' != '" + 214 + "'", value.equals(BigInteger.valueOf( 214L ) ) ); } else { value = value.longValue(); expected = 214L; @@ -1285,9 +834,7 @@ public void test1() throws Throwable { } value = msg.rle_list[93]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[93] + "' != '" + 241 + "'", - value.equals(BigInteger.valueOf(241L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[93] + "' != '" + 241 + "'", value.equals(BigInteger.valueOf( 241L ) ) ); } else { value = value.longValue(); expected = 241L; @@ -1295,9 +842,7 @@ public void test1() throws Throwable { } value = msg.rle_list[94]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[94] + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[94] + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -1305,9 +850,7 @@ public void test1() throws Throwable { } value = msg.rle_list[95]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[95] + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[95] + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -1315,9 +858,7 @@ public void test1() throws Throwable { } value = msg.rle_list[96]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[96] + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[96] + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -1325,9 +866,7 @@ public void test1() throws Throwable { } value = msg.rle_list[97]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[97] + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[97] + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -1335,9 +874,7 @@ public void test1() throws Throwable { } value = msg.rle_list[98]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[98] + "' != '" + 89 + "'", - value.equals(BigInteger.valueOf(89L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[98] + "' != '" + 89 + "'", value.equals(BigInteger.valueOf( 89L ) ) ); } else { value = value.longValue(); expected = 89L; @@ -1345,9 +882,7 @@ public void test1() throws Throwable { } value = msg.rle_list[99]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[99] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[99] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1355,9 +890,7 @@ public void test1() throws Throwable { } value = msg.rle_list[100]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[100] + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[100] + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -1365,9 +898,7 @@ public void test1() throws Throwable { } value = msg.rle_list[101]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[101] + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[101] + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -1375,9 +906,7 @@ public void test1() throws Throwable { } value = msg.rle_list[102]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[102] + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[102] + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -1385,9 +914,7 @@ public void test1() throws Throwable { } value = msg.rle_list[103]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[103] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[103] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -1395,9 +922,7 @@ public void test1() throws Throwable { } value = msg.rle_list[104]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[104] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[104] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -1405,9 +930,7 @@ public void test1() throws Throwable { } value = msg.rle_list[105]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[105] + "' != '" + 153 + "'", - value.equals(BigInteger.valueOf(153L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[105] + "' != '" + 153 + "'", value.equals(BigInteger.valueOf( 153L ) ) ); } else { value = value.longValue(); expected = 153L; @@ -1415,9 +938,7 @@ public void test1() throws Throwable { } value = msg.rle_list[106]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[106] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[106] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -1425,9 +946,7 @@ public void test1() throws Throwable { } value = msg.rle_list[107]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[107] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[107] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -1435,9 +954,7 @@ public void test1() throws Throwable { } value = msg.rle_list[108]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[108] + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[108] + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -1445,9 +962,7 @@ public void test1() throws Throwable { } value = msg.rle_list[109]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[109] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[109] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -1455,9 +970,7 @@ public void test1() throws Throwable { } value = msg.rle_list[110]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[110] + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[110] + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -1465,9 +978,7 @@ public void test1() throws Throwable { } value = msg.rle_list[111]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[111] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[111] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -1475,9 +986,7 @@ public void test1() throws Throwable { } value = msg.rle_list[112]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[112] + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[112] + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1485,9 +994,7 @@ public void test1() throws Throwable { } value = msg.rle_list[113]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[113] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[113] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -1495,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.rle_list[114]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[114] + "' != '" + 139 + "'", - value.equals(BigInteger.valueOf(139L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[114] + "' != '" + 139 + "'", value.equals(BigInteger.valueOf( 139L ) ) ); } else { value = value.longValue(); expected = 139L; @@ -1505,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.rle_list[115]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[115] + "' != '" + 122 + "'", - value.equals(BigInteger.valueOf(122L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[115] + "' != '" + 122 + "'", value.equals(BigInteger.valueOf( 122L ) ) ); } else { value = value.longValue(); expected = 122L; @@ -1515,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.rle_list[116]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[116] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[116] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -1525,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.rle_list[117]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[117] + "' != '" + 90 + "'", - value.equals(BigInteger.valueOf(90L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[117] + "' != '" + 90 + "'", value.equals(BigInteger.valueOf( 90L ) ) ); } else { value = value.longValue(); expected = 90L; @@ -1535,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.rle_list[118]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[118] + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[118] + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -1545,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.rle_list[119]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[119] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[119] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -1555,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.rle_list[120]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[120] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[120] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1565,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.rle_list[121]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[121] + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[121] + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -1575,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.rle_list[122]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[122] + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[122] + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -1585,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.rle_list[123]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[123] + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[123] + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -1595,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.rle_list[124]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[124] + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[124] + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -1605,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.rle_list[125]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[125] + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[125] + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -1615,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.rle_list[126]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[126] + "' != '" + 243 + "'", - value.equals(BigInteger.valueOf(243L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[126] + "' != '" + 243 + "'", value.equals(BigInteger.valueOf( 243L ) ) ); } else { value = value.longValue(); expected = 243L; @@ -1625,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.rle_list[127]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[127] + "' != '" + 198 + "'", - value.equals(BigInteger.valueOf(198L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[127] + "' != '" + 198 + "'", value.equals(BigInteger.valueOf( 198L ) ) ); } else { value = value.longValue(); expected = 198L; @@ -1635,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.rle_list[128]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[128] + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[128] + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -1645,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.rle_list[129]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[129] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[129] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -1655,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.rle_list[130]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[130] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[130] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -1665,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.rle_list[131]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[131] + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[131] + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -1675,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.rle_list[132]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[132] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[132] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1685,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.rle_list[133]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[133] + "' != '" + 135 + "'", - value.equals(BigInteger.valueOf(135L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[133] + "' != '" + 135 + "'", value.equals(BigInteger.valueOf( 135L ) ) ); } else { value = value.longValue(); expected = 135L; @@ -1695,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.rle_list[134]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[134] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[134] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -1705,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.rle_list[135]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[135] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[135] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -1715,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.rle_list[136]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[136] + "' != '" + 150 + "'", - value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[136] + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -1725,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.rle_list[137]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[137] + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[137] + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -1735,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.rle_list[138]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[138] + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[138] + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -1745,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.rle_list[139]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[139] + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[139] + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -1755,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.rle_list[140]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[140] + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[140] + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -1765,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.rle_list[141]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[141] + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[141] + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -1775,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.rle_list[142]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[142] + "' != '" + 252 + "'", - value.equals(BigInteger.valueOf(252L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[142] + "' != '" + 252 + "'", value.equals(BigInteger.valueOf( 252L ) ) ); } else { value = value.longValue(); expected = 252L; @@ -1785,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.rle_list[143]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[143] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[143] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -1795,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.rle_list[144]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[144] + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[144] + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -1805,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.rle_list[145]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[145] + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[145] + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -1815,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.rle_list[146]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[146] + "' != '" + 204 + "'", - value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[146] + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -1825,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.rle_list[147]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[147] + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[147] + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -1835,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.rle_list[148]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[148] + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[148] + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -1845,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.rle_list[149]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[149] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[149] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -1855,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.rle_list[150]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[150] + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[150] + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -1865,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.rle_list[151]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[151] + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[151] + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -1875,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.rle_list[152]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[152] + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[152] + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -1885,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.rle_list[153]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[153] + "' != '" + 94 + "'", - value.equals(BigInteger.valueOf(94L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[153] + "' != '" + 94 + "'", value.equals(BigInteger.valueOf( 94L ) ) ); } else { value = value.longValue(); expected = 94L; @@ -1895,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.rle_list[154]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[154] + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[154] + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -1905,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.rle_list[155]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[155] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[155] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -1915,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.rle_list[156]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[156] + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[156] + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -1925,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.rle_list[157]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[157] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[157] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1935,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.rle_list[158]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[158] + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[158] + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -1945,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.rle_list[159]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[159] + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[159] + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -1955,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.rle_list[160]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[160] + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[160] + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -1965,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.rle_list[161]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[161] + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[161] + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -1975,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.rle_list[162]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[162] + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[162] + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -1985,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.rle_list[163]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[163] + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[163] + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -1995,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.rle_list[164]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[164] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[164] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -2005,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.rle_list[165]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[165] + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[165] + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -2015,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.rle_list[166]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[166] + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[166] + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -2025,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.rle_list[167]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[167] + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[167] + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -2035,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.rle_list[168]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[168] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[168] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -2045,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.rle_list[169]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[169] + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[169] + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -2055,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.rle_list[170]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[170] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[170] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -2065,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.rle_list[171]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[171] + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[171] + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -2075,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.rle_list[172]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[172] + "' != '" + 251 + "'", - value.equals(BigInteger.valueOf(251L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[172] + "' != '" + 251 + "'", value.equals(BigInteger.valueOf( 251L ) ) ); } else { value = value.longValue(); expected = 251L; @@ -2085,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.rle_list[173]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[173] + "' != '" + 164 + "'", - value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[173] + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -2095,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.rle_list[174]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[174] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[174] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -2105,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.rle_list[175]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[175] + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[175] + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -2115,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.rle_list[176]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[176] + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[176] + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -2125,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.rle_list[177]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[177] + "' != '" + 226 + "'", - value.equals(BigInteger.valueOf(226L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[177] + "' != '" + 226 + "'", value.equals(BigInteger.valueOf( 226L ) ) ); } else { value = value.longValue(); expected = 226L; @@ -2135,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.rle_list[178]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[178] + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[178] + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -2145,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.rle_list[179]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[179] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[179] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -2155,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.rle_list[180]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[180] + "' != '" + 170 + "'", - value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[180] + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -2165,9 +1538,7 @@ public void test1() throws Throwable { } value = msg.rle_list[181]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[181] + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[181] + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -2175,9 +1546,7 @@ public void test1() throws Throwable { } value = msg.rle_list[182]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[182] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[182] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -2185,9 +1554,7 @@ public void test1() throws Throwable { } value = msg.rle_list[183]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[183] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[183] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -2195,9 +1562,7 @@ public void test1() throws Throwable { } value = msg.rle_list[184]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[184] + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[184] + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -2205,9 +1570,7 @@ public void test1() throws Throwable { } value = msg.rle_list[185]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[185] + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[185] + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -2215,9 +1578,7 @@ public void test1() throws Throwable { } value = msg.rle_list[186]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[186] + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[186] + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -2225,9 +1586,7 @@ public void test1() throws Throwable { } value = msg.rle_list[187]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[187] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[187] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -2235,9 +1594,7 @@ public void test1() throws Throwable { } value = msg.rle_list[188]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[188] + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[188] + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -2245,9 +1602,7 @@ public void test1() throws Throwable { } value = msg.rle_list[189]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[189] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[189] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -2255,9 +1610,7 @@ public void test1() throws Throwable { } value = msg.rle_list[190]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[190] + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[190] + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -2265,9 +1618,7 @@ public void test1() throws Throwable { } value = msg.rle_list[191]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[191] + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[191] + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -2275,9 +1626,7 @@ public void test1() throws Throwable { } value = msg.rle_list[192]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[192] + "' != '" + 247 + "'", - value.equals(BigInteger.valueOf(247L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[192] + "' != '" + 247 + "'", value.equals(BigInteger.valueOf( 247L ) ) ); } else { value = value.longValue(); expected = 247L; @@ -2285,9 +1634,7 @@ public void test1() throws Throwable { } value = msg.rle_list[193]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[193] + "' != '" + 159 + "'", - value.equals(BigInteger.valueOf(159L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[193] + "' != '" + 159 + "'", value.equals(BigInteger.valueOf( 159L ) ) ); } else { value = value.longValue(); expected = 159L; @@ -2295,9 +1642,7 @@ public void test1() throws Throwable { } value = msg.rle_list[194]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[194] + "' != '" + 189 + "'", - value.equals(BigInteger.valueOf(189L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[194] + "' != '" + 189 + "'", value.equals(BigInteger.valueOf( 189L ) ) ); } else { value = value.longValue(); expected = 189L; @@ -2305,9 +1650,7 @@ public void test1() throws Throwable { } value = msg.rle_list[195]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[195] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[195] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -2315,9 +1658,7 @@ public void test1() throws Throwable { } value = msg.rle_list[196]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[196] + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[196] + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -2325,9 +1666,7 @@ public void test1() throws Throwable { } value = msg.rle_list[197]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[197] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[197] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -2335,9 +1674,7 @@ public void test1() throws Throwable { } value = msg.rle_list[198]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[198] + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[198] + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -2345,9 +1682,7 @@ public void test1() throws Throwable { } value = msg.rle_list[199]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[199] + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[199] + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -2355,9 +1690,7 @@ public void test1() throws Throwable { } value = msg.rle_list[200]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[200] + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[200] + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -2365,9 +1698,7 @@ public void test1() throws Throwable { } value = msg.rle_list[201]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[201] + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[201] + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -2375,9 +1706,7 @@ public void test1() throws Throwable { } value = msg.rle_list[202]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[202] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[202] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -2385,9 +1714,7 @@ public void test1() throws Throwable { } value = msg.rle_list[203]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[203] + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[203] + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -2395,9 +1722,7 @@ public void test1() throws Throwable { } value = msg.rle_list[204]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[204] + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[204] + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -2405,9 +1730,7 @@ public void test1() throws Throwable { } value = msg.rle_list[205]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[205] + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[205] + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -2415,9 +1738,7 @@ public void test1() throws Throwable { } value = msg.rle_list[206]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[206] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[206] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -2425,9 +1746,7 @@ public void test1() throws Throwable { } value = msg.rle_list[207]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[207] + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[207] + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -2435,9 +1754,7 @@ public void test1() throws Throwable { } value = msg.rle_list[208]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[208] + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[208] + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -2445,9 +1762,7 @@ public void test1() throws Throwable { } value = msg.rle_list[209]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[209] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[209] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -2455,9 +1770,7 @@ public void test1() throws Throwable { } value = msg.rle_list[210]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[210] + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[210] + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -2465,9 +1778,7 @@ public void test1() throws Throwable { } value = msg.rle_list[211]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[211] + "' != '" + 136 + "'", - value.equals(BigInteger.valueOf(136L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[211] + "' != '" + 136 + "'", value.equals(BigInteger.valueOf( 136L ) ) ); } else { value = value.longValue(); expected = 136L; @@ -2475,9 +1786,7 @@ public void test1() throws Throwable { } value = msg.rle_list[212]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[212] + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[212] + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -2485,9 +1794,7 @@ public void test1() throws Throwable { } value = msg.rle_list[213]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[213] + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[213] + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -2495,9 +1802,7 @@ public void test1() throws Throwable { } value = msg.rle_list[214]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[214] + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[214] + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -2505,9 +1810,7 @@ public void test1() throws Throwable { } value = msg.rle_list[215]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[215] + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[215] + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -2515,9 +1818,7 @@ public void test1() throws Throwable { } value = msg.rle_list[216]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[216] + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[216] + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -2525,9 +1826,7 @@ public void test1() throws Throwable { } value = msg.rle_list[217]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[217] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[217] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -2535,9 +1834,7 @@ public void test1() throws Throwable { } value = msg.rle_list[218]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[218] + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[218] + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -2545,9 +1842,7 @@ public void test1() throws Throwable { } value = msg.rle_list[219]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[219] + "' != '" + 206 + "'", - value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[219] + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; @@ -2555,9 +1850,7 @@ public void test1() throws Throwable { } value = msg.rle_list[220]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[220] + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[220] + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -2565,9 +1858,7 @@ public void test1() throws Throwable { } value = msg.rle_list[221]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[221] + "' != '" + 252 + "'", - value.equals(BigInteger.valueOf(252L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[221] + "' != '" + 252 + "'", value.equals(BigInteger.valueOf( 252L ) ) ); } else { value = value.longValue(); expected = 252L; @@ -2575,9 +1866,7 @@ public void test1() throws Throwable { } value = msg.rle_list[222]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[222] + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[222] + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -2585,9 +1874,7 @@ public void test1() throws Throwable { } value = msg.rle_list[223]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[223] + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[223] + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -2595,9 +1882,7 @@ public void test1() throws Throwable { } value = msg.rle_list[224]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[224] + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[224] + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -2605,9 +1890,7 @@ public void test1() throws Throwable { } value = msg.rle_list[225]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[225] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[225] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -2615,9 +1898,7 @@ public void test1() throws Throwable { } value = msg.rle_list[226]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[226] + "' != '" + 206 + "'", - value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[226] + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; @@ -2625,9 +1906,7 @@ public void test1() throws Throwable { } value = msg.rle_list[227]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[227] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[227] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -2635,9 +1914,7 @@ public void test1() throws Throwable { } value = msg.rle_list[228]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[228] + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[228] + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -2645,9 +1922,7 @@ public void test1() throws Throwable { } value = msg.rle_list[229]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[229] + "' != '" + 243 + "'", - value.equals(BigInteger.valueOf(243L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[229] + "' != '" + 243 + "'", value.equals(BigInteger.valueOf( 243L ) ) ); } else { value = value.longValue(); expected = 243L; @@ -2655,9 +1930,7 @@ public void test1() throws Throwable { } value = msg.rle_list[230]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[230] + "' != '" + 158 + "'", - value.equals(BigInteger.valueOf(158L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[230] + "' != '" + 158 + "'", value.equals(BigInteger.valueOf( 158L ) ) ); } else { value = value.longValue(); expected = 158L; @@ -2665,9 +1938,7 @@ public void test1() throws Throwable { } value = msg.rle_list[231]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[231] + "' != '" + 94 + "'", - value.equals(BigInteger.valueOf(94L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[231] + "' != '" + 94 + "'", value.equals(BigInteger.valueOf( 94L ) ) ); } else { value = value.longValue(); expected = 94L; @@ -2675,9 +1946,7 @@ public void test1() throws Throwable { } value = msg.rle_list[232]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[232] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[232] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -2685,9 +1954,7 @@ public void test1() throws Throwable { } value = msg.rle_list[233]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[233] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[233] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -2695,9 +1962,7 @@ public void test1() throws Throwable { } value = msg.rle_list[234]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[234] + "' != '" + 205 + "'", - value.equals(BigInteger.valueOf(205L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[234] + "' != '" + 205 + "'", value.equals(BigInteger.valueOf( 205L ) ) ); } else { value = value.longValue(); expected = 205L; @@ -2705,9 +1970,7 @@ public void test1() throws Throwable { } value = msg.rle_list[235]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[235] + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[235] + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -2715,9 +1978,7 @@ public void test1() throws Throwable { } value = msg.rle_list[236]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[236] + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[236] + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -2725,9 +1986,7 @@ public void test1() throws Throwable { } value = msg.rle_list[237]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[237] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[237] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -2735,9 +1994,7 @@ public void test1() throws Throwable { } value = msg.rle_list[238]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[238] + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[238] + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -2745,9 +2002,7 @@ public void test1() throws Throwable { } value = msg.rle_list[239]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[239] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[239] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -2755,9 +2010,7 @@ public void test1() throws Throwable { } value = msg.rle_list[240]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[240] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[240] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -2765,9 +2018,7 @@ public void test1() throws Throwable { } value = msg.rle_list[241]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[241] + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[241] + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -2775,9 +2026,7 @@ public void test1() throws Throwable { } value = msg.rle_list[242]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[242] + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[242] + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -2785,9 +2034,7 @@ public void test1() throws Throwable { } value = msg.rle_list[243]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[243] + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[243] + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -2795,9 +2042,7 @@ public void test1() throws Throwable { } value = msg.rle_list[244]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[244] + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[244] + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -2805,9 +2050,7 @@ public void test1() throws Throwable { } value = msg.rle_list[245]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rle_list[245] + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.rle_list[245] + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.java b/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.java index f65ea43d5..ec8b0d2fa 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionBounds.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionBounds.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrectionBounds; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest { @@ -29,28 +33,16 @@ public class auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.test1"); - byte[] payload = - new byte[] { - (byte) 180, (byte) 0, (byte) 0, (byte) 0, (byte) 3, (byte) 0, (byte) 1, - (byte) 0, (byte) 10, (byte) 0, (byte) 15, (byte) 1, (byte) 0, (byte) 10, - (byte) 0, (byte) 39, (byte) 232, (byte) 3, (byte) 244, (byte) 1, (byte) 100, - (byte) 200, (byte) 150, (byte) 100, (byte) 150, (byte) 100, (byte) 2, (byte) 5, - (byte) 10, (byte) 16, (byte) 0, (byte) 17, (byte) 18, (byte) 19, (byte) 20, - (byte) 21, (byte) 6, (byte) 10, (byte) 22, (byte) 0, (byte) 23, (byte) 24, - (byte) 25, (byte) 26, (byte) 27, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x05FE, payload); - MsgSsrGriddedCorrectionBounds msg = new MsgSsrGriddedCorrectionBounds(sbp); + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.test1"); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)1,(byte)0,(byte)10,(byte)0,(byte)15,(byte)1,(byte)0,(byte)10,(byte)0,(byte)39,(byte)232,(byte)3,(byte)244,(byte)1,(byte)100,(byte)200,(byte)150,(byte)100,(byte)150,(byte)100,(byte)2,(byte)5,(byte)10,(byte)16,(byte)0,(byte)17,(byte)18,(byte)19,(byte)20,(byte)21,(byte)6,(byte)10,(byte)22,(byte)0,(byte)23,(byte)24,(byte)25,(byte)26,(byte)27, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x05FE, payload ); + MsgSsrGriddedCorrectionBounds msg = new MsgSsrGriddedCorrectionBounds( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.grid_point_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.grid_point_id + "' != '" + 1000 + "'", - value.equals(BigInteger.valueOf(1000L))); + org.junit.Assert.assertTrue("'" + msg.grid_point_id + "' != '" + 1000 + "'", value.equals(BigInteger.valueOf( 1000L ) ) ); } else { value = value.longValue(); expected = 1000L; @@ -58,9 +50,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -68,9 +58,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -78,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.sol_id + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.header.sol_id + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -88,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.header.time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -98,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -108,9 +90,7 @@ public void test1() throws Throwable { } value = msg.header.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.update_interval + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.header.update_interval + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -118,8 +98,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -127,9 +106,7 @@ public void test1() throws Throwable { } value = msg.ssr_iod_atmo; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ssr_iod_atmo + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.ssr_iod_atmo + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -137,9 +114,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_bound_mu + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_bound_mu + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -147,9 +122,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_bound_mu_dot; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_bound_mu_dot + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_bound_mu_dot + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -157,9 +130,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_bound_sig + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_bound_sig + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -167,9 +138,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_bound_sig_dot; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_bound_sig_dot + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_bound_sig_dot + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -177,9 +146,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_residual.residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_residual.residual + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_residual.residual + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -187,9 +154,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_residual.stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_residual.stddev + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_residual.stddev + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -197,13 +162,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_residual.sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" - + msg.stec_sat_list[0].stec_residual.sv_id.constellation - + "' != '" - + 10 - + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_residual.sv_id.constellation + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -211,9 +170,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_residual.sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_residual.sv_id.satId + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_residual.sv_id.satId + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -221,9 +178,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_bound_mu + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_bound_mu + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -231,9 +186,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_bound_mu_dot; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_bound_mu_dot + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_bound_mu_dot + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -241,9 +194,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_bound_sig + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_bound_sig + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -251,9 +202,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_bound_sig_dot; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_bound_sig_dot + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_bound_sig_dot + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -261,9 +210,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_residual.residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_residual.residual + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_residual.residual + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -271,9 +218,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_residual.stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_residual.stddev + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_residual.stddev + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -281,13 +226,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_residual.sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" - + msg.stec_sat_list[1].stec_residual.sv_id.constellation - + "' != '" - + 10 - + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_residual.sv_id.constellation + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -295,9 +234,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_residual.sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_residual.sv_id.satId + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_residual.sv_id.satId + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -305,8 +242,7 @@ public void test1() throws Throwable { } value = msg.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_id + "' != '" + 10 + "'", value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.tile_id + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -314,9 +250,7 @@ public void test1() throws Throwable { } value = msg.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_set_id + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.tile_set_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -324,9 +258,7 @@ public void test1() throws Throwable { } value = msg.tropo_delay_correction.hydro; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.hydro + "' != '" + 500 + "'", - value.equals(BigInteger.valueOf(500L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.hydro + "' != '" + 500 + "'", value.equals(BigInteger.valueOf( 500L ) ) ); } else { value = value.longValue(); expected = 500L; @@ -334,9 +266,7 @@ public void test1() throws Throwable { } value = msg.tropo_delay_correction.stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.stddev + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.stddev + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -344,9 +274,7 @@ public void test1() throws Throwable { } value = msg.tropo_delay_correction.wet; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.wet + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.wet + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -354,9 +282,7 @@ public void test1() throws Throwable { } value = msg.tropo_qi; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_qi + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.tropo_qi + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -364,9 +290,7 @@ public void test1() throws Throwable { } value = msg.tropo_v_hydro_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_v_hydro_bound_mu + "' != '" + 150 + "'", - value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.tropo_v_hydro_bound_mu + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -374,9 +298,7 @@ public void test1() throws Throwable { } value = msg.tropo_v_hydro_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_v_hydro_bound_sig + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.tropo_v_hydro_bound_sig + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -384,9 +306,7 @@ public void test1() throws Throwable { } value = msg.tropo_v_wet_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_v_wet_bound_mu + "' != '" + 150 + "'", - value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.tropo_v_wet_bound_mu + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -394,9 +314,7 @@ public void test1() throws Throwable { } value = msg.tropo_v_wet_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_v_wet_bound_sig + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.tropo_v_wet_bound_sig + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -409,25 +327,16 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.test2"); - byte[] payload = - new byte[] { - (byte) 180, (byte) 0, (byte) 0, (byte) 0, (byte) 3, (byte) 0, (byte) 1, - (byte) 0, (byte) 10, (byte) 0, (byte) 15, (byte) 1, (byte) 0, (byte) 10, - (byte) 0, (byte) 39, (byte) 232, (byte) 3, (byte) 244, (byte) 1, (byte) 100, - (byte) 200, (byte) 150, (byte) 100, (byte) 150, (byte) 100, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x05FE, payload); - MsgSsrGriddedCorrectionBounds msg = new MsgSsrGriddedCorrectionBounds(sbp); + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrGriddedCorrectionBoundsTest.test2"); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)1,(byte)0,(byte)10,(byte)0,(byte)15,(byte)1,(byte)0,(byte)10,(byte)0,(byte)39,(byte)232,(byte)3,(byte)244,(byte)1,(byte)100,(byte)200,(byte)150,(byte)100,(byte)150,(byte)100,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x05FE, payload ); + MsgSsrGriddedCorrectionBounds msg = new MsgSsrGriddedCorrectionBounds( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.grid_point_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.grid_point_id + "' != '" + 1000 + "'", - value.equals(BigInteger.valueOf(1000L))); + org.junit.Assert.assertTrue("'" + msg.grid_point_id + "' != '" + 1000 + "'", value.equals(BigInteger.valueOf( 1000L ) ) ); } else { value = value.longValue(); expected = 1000L; @@ -435,9 +344,7 @@ public void test2() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -445,9 +352,7 @@ public void test2() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -455,9 +360,7 @@ public void test2() throws Throwable { } value = msg.header.sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.sol_id + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.header.sol_id + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -465,9 +368,7 @@ public void test2() throws Throwable { } value = msg.header.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.header.time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -475,9 +376,7 @@ public void test2() throws Throwable { } value = msg.header.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -485,9 +384,7 @@ public void test2() throws Throwable { } value = msg.header.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.update_interval + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.header.update_interval + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -495,8 +392,7 @@ public void test2() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -504,9 +400,7 @@ public void test2() throws Throwable { } value = msg.ssr_iod_atmo; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ssr_iod_atmo + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.ssr_iod_atmo + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -514,8 +408,7 @@ public void test2() throws Throwable { } value = msg.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_id + "' != '" + 10 + "'", value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.tile_id + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -523,9 +416,7 @@ public void test2() throws Throwable { } value = msg.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_set_id + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.tile_set_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -533,9 +424,7 @@ public void test2() throws Throwable { } value = msg.tropo_delay_correction.hydro; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.hydro + "' != '" + 500 + "'", - value.equals(BigInteger.valueOf(500L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.hydro + "' != '" + 500 + "'", value.equals(BigInteger.valueOf( 500L ) ) ); } else { value = value.longValue(); expected = 500L; @@ -543,9 +432,7 @@ public void test2() throws Throwable { } value = msg.tropo_delay_correction.stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.stddev + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.stddev + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -553,9 +440,7 @@ public void test2() throws Throwable { } value = msg.tropo_delay_correction.wet; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.wet + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.wet + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -563,9 +448,7 @@ public void test2() throws Throwable { } value = msg.tropo_qi; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_qi + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.tropo_qi + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -573,9 +456,7 @@ public void test2() throws Throwable { } value = msg.tropo_v_hydro_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_v_hydro_bound_mu + "' != '" + 150 + "'", - value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.tropo_v_hydro_bound_mu + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -583,9 +464,7 @@ public void test2() throws Throwable { } value = msg.tropo_v_hydro_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_v_hydro_bound_sig + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.tropo_v_hydro_bound_sig + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -593,9 +472,7 @@ public void test2() throws Throwable { } value = msg.tropo_v_wet_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_v_wet_bound_mu + "' != '" + 150 + "'", - value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.tropo_v_wet_bound_mu + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -603,9 +480,7 @@ public void test2() throws Throwable { } value = msg.tropo_v_wet_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_v_wet_bound_sig + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.tropo_v_wet_bound_sig + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionDepATest.java b/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionDepATest.java index a912338c8..05af54590 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionDepATest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionDepA.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrectionDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrGriddedCorrectionDepATest { @@ -30,273 +34,15 @@ public class auto_check_sbp_ssr_MsgSsrGriddedCorrectionDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrGriddedCorrectionDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 164, - (byte) 217, - (byte) 44, - (byte) 53, - (byte) 98, - (byte) 93, - (byte) 63, - (byte) 147, - (byte) 104, - (byte) 252, - (byte) 133, - (byte) 245, - (byte) 28, - (byte) 95, - (byte) 100, - (byte) 147, - (byte) 41, - (byte) 33, - (byte) 92, - (byte) 87, - (byte) 25, - (byte) 142, - (byte) 151, - (byte) 74, - (byte) 151, - (byte) 95, - (byte) 94, - (byte) 7, - (byte) 146, - (byte) 237, - (byte) 45, - (byte) 167, - (byte) 86, - (byte) 42, - (byte) 116, - (byte) 224, - (byte) 169, - (byte) 234, - (byte) 220, - (byte) 23, - (byte) 176, - (byte) 18, - (byte) 13, - (byte) 178, - (byte) 79, - (byte) 160, - (byte) 160, - (byte) 110, - (byte) 15, - (byte) 53, - (byte) 206, - (byte) 151, - (byte) 158, - (byte) 22, - (byte) 117, - (byte) 184, - (byte) 48, - (byte) 170, - (byte) 82, - (byte) 40, - (byte) 53, - (byte) 122, - (byte) 69, - (byte) 180, - (byte) 110, - (byte) 38, - (byte) 65, - (byte) 104, - (byte) 244, - (byte) 19, - (byte) 238, - (byte) 227, - (byte) 88, - (byte) 169, - (byte) 164, - (byte) 146, - (byte) 63, - (byte) 37, - (byte) 183, - (byte) 85, - (byte) 71, - (byte) 235, - (byte) 168, - (byte) 114, - (byte) 211, - (byte) 105, - (byte) 221, - (byte) 156, - (byte) 60, - (byte) 18, - (byte) 230, - (byte) 2, - (byte) 142, - (byte) 172, - (byte) 16, - (byte) 39, - (byte) 33, - (byte) 126, - (byte) 106, - (byte) 99, - (byte) 188, - (byte) 234, - (byte) 41, - (byte) 162, - (byte) 197, - (byte) 138, - (byte) 227, - (byte) 80, - (byte) 12, - (byte) 54, - (byte) 67, - (byte) 238, - (byte) 5, - (byte) 93, - (byte) 1, - (byte) 207, - (byte) 129, - (byte) 13, - (byte) 46, - (byte) 115, - (byte) 49, - (byte) 58, - (byte) 185, - (byte) 127, - (byte) 156, - (byte) 200, - (byte) 96, - (byte) 217, - (byte) 202, - (byte) 15, - (byte) 245, - (byte) 55, - (byte) 198, - (byte) 81, - (byte) 218, - (byte) 132, - (byte) 70, - (byte) 73, - (byte) 82, - (byte) 147, - (byte) 26, - (byte) 255, - (byte) 14, - (byte) 134, - (byte) 96, - (byte) 138, - (byte) 55, - (byte) 214, - (byte) 83, - (byte) 156, - (byte) 170, - (byte) 163, - (byte) 79, - (byte) 173, - (byte) 228, - (byte) 115, - (byte) 51, - (byte) 241, - (byte) 107, - (byte) 245, - (byte) 112, - (byte) 168, - (byte) 210, - (byte) 10, - (byte) 5, - (byte) 117, - (byte) 1, - (byte) 57, - (byte) 108, - (byte) 248, - (byte) 212, - (byte) 145, - (byte) 119, - (byte) 226, - (byte) 165, - (byte) 5, - (byte) 141, - (byte) 202, - (byte) 106, - (byte) 0, - (byte) 60, - (byte) 36, - (byte) 61, - (byte) 243, - (byte) 203, - (byte) 216, - (byte) 215, - (byte) 12, - (byte) 137, - (byte) 16, - (byte) 28, - (byte) 247, - (byte) 115, - (byte) 152, - (byte) 181, - (byte) 119, - (byte) 208, - (byte) 228, - (byte) 203, - (byte) 236, - (byte) 34, - (byte) 167, - (byte) 196, - (byte) 32, - (byte) 109, - (byte) 1, - (byte) 17, - (byte) 101, - (byte) 200, - (byte) 25, - (byte) 94, - (byte) 125, - (byte) 168, - (byte) 137, - (byte) 157, - (byte) 4, - (byte) 164, - (byte) 29, - (byte) 31, - (byte) 48, - (byte) 132, - (byte) 72, - (byte) 229, - (byte) 126, - (byte) 186, - (byte) 68, - (byte) 76, - (byte) 133, - (byte) 21, - (byte) 0, - (byte) 180, - (byte) 139, - (byte) 164, - (byte) 148, - (byte) 119, - (byte) 149, - (byte) 214, - (byte) 120, - (byte) 177, - (byte) 201, - (byte) 80, - (byte) 80, - (byte) 105, - (byte) 10, - (byte) 136, - (byte) 118, - (byte) 77, - (byte) 46, - (byte) 233, - (byte) 233, - (byte) 227, - (byte) 11, - (byte) 158, - (byte) 103, - }; - SBPMessage sbp = new SBPMessage(0x6a6c, 0x5fa, payload); - MsgSsrGriddedCorrectionDepA msg = new MsgSsrGriddedCorrectionDepA(sbp); + byte[] payload = new byte[] {(byte)164,(byte)217,(byte)44,(byte)53,(byte)98,(byte)93,(byte)63,(byte)147,(byte)104,(byte)252,(byte)133,(byte)245,(byte)28,(byte)95,(byte)100,(byte)147,(byte)41,(byte)33,(byte)92,(byte)87,(byte)25,(byte)142,(byte)151,(byte)74,(byte)151,(byte)95,(byte)94,(byte)7,(byte)146,(byte)237,(byte)45,(byte)167,(byte)86,(byte)42,(byte)116,(byte)224,(byte)169,(byte)234,(byte)220,(byte)23,(byte)176,(byte)18,(byte)13,(byte)178,(byte)79,(byte)160,(byte)160,(byte)110,(byte)15,(byte)53,(byte)206,(byte)151,(byte)158,(byte)22,(byte)117,(byte)184,(byte)48,(byte)170,(byte)82,(byte)40,(byte)53,(byte)122,(byte)69,(byte)180,(byte)110,(byte)38,(byte)65,(byte)104,(byte)244,(byte)19,(byte)238,(byte)227,(byte)88,(byte)169,(byte)164,(byte)146,(byte)63,(byte)37,(byte)183,(byte)85,(byte)71,(byte)235,(byte)168,(byte)114,(byte)211,(byte)105,(byte)221,(byte)156,(byte)60,(byte)18,(byte)230,(byte)2,(byte)142,(byte)172,(byte)16,(byte)39,(byte)33,(byte)126,(byte)106,(byte)99,(byte)188,(byte)234,(byte)41,(byte)162,(byte)197,(byte)138,(byte)227,(byte)80,(byte)12,(byte)54,(byte)67,(byte)238,(byte)5,(byte)93,(byte)1,(byte)207,(byte)129,(byte)13,(byte)46,(byte)115,(byte)49,(byte)58,(byte)185,(byte)127,(byte)156,(byte)200,(byte)96,(byte)217,(byte)202,(byte)15,(byte)245,(byte)55,(byte)198,(byte)81,(byte)218,(byte)132,(byte)70,(byte)73,(byte)82,(byte)147,(byte)26,(byte)255,(byte)14,(byte)134,(byte)96,(byte)138,(byte)55,(byte)214,(byte)83,(byte)156,(byte)170,(byte)163,(byte)79,(byte)173,(byte)228,(byte)115,(byte)51,(byte)241,(byte)107,(byte)245,(byte)112,(byte)168,(byte)210,(byte)10,(byte)5,(byte)117,(byte)1,(byte)57,(byte)108,(byte)248,(byte)212,(byte)145,(byte)119,(byte)226,(byte)165,(byte)5,(byte)141,(byte)202,(byte)106,(byte)0,(byte)60,(byte)36,(byte)61,(byte)243,(byte)203,(byte)216,(byte)215,(byte)12,(byte)137,(byte)16,(byte)28,(byte)247,(byte)115,(byte)152,(byte)181,(byte)119,(byte)208,(byte)228,(byte)203,(byte)236,(byte)34,(byte)167,(byte)196,(byte)32,(byte)109,(byte)1,(byte)17,(byte)101,(byte)200,(byte)25,(byte)94,(byte)125,(byte)168,(byte)137,(byte)157,(byte)4,(byte)164,(byte)29,(byte)31,(byte)48,(byte)132,(byte)72,(byte)229,(byte)126,(byte)186,(byte)68,(byte)76,(byte)133,(byte)21,(byte)0,(byte)180,(byte)139,(byte)164,(byte)148,(byte)119,(byte)149,(byte)214,(byte)120,(byte)177,(byte)201,(byte)80,(byte)80,(byte)105,(byte)10,(byte)136,(byte)118,(byte)77,(byte)46,(byte)233,(byte)233,(byte)227,(byte)11,(byte)158,(byte)103, }; + SBPMessage sbp = new SBPMessage( 0x6a6c, 0x5fa, payload ); + MsgSsrGriddedCorrectionDepA msg = new MsgSsrGriddedCorrectionDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.header.iod_atmo; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.iod_atmo + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.header.iod_atmo + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -304,9 +50,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 37695 + "'", - value.equals(BigInteger.valueOf(37695L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 37695 + "'", value.equals(BigInteger.valueOf( 37695L ) ) ); } else { value = value.longValue(); expected = 37695L; @@ -314,9 +58,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 64616 + "'", - value.equals(BigInteger.valueOf(64616L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 64616 + "'", value.equals(BigInteger.valueOf( 64616L ) ) ); } else { value = value.longValue(); expected = 64616L; @@ -324,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.tow + "' != '" + 892131748 + "'", - value.equals(BigInteger.valueOf(892131748L))); + org.junit.Assert.assertTrue("'" + msg.header.time.tow + "' != '" + 892131748 + "'", value.equals(BigInteger.valueOf( 892131748L ) ) ); } else { value = value.longValue(); expected = 892131748L; @@ -334,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.wn + "' != '" + 23906 + "'", - value.equals(BigInteger.valueOf(23906L))); + org.junit.Assert.assertTrue("'" + msg.header.time.wn + "' != '" + 23906 + "'", value.equals(BigInteger.valueOf( 23906L ) ) ); } else { value = value.longValue(); expected = 23906L; @@ -344,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.tropo_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tropo_quality_indicator + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.header.tropo_quality_indicator + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -354,9 +90,7 @@ public void test1() throws Throwable { } value = msg.header.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.update_interval + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.header.update_interval + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -364,9 +98,7 @@ public void test1() throws Throwable { } value = msg.index; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.index + "' != '" + 25695 + "'", - value.equals(BigInteger.valueOf(25695L))); + org.junit.Assert.assertTrue("'" + msg.index + "' != '" + 25695 + "'", value.equals(BigInteger.valueOf( 25695L ) ) ); } else { value = value.longValue(); expected = 25695L; @@ -374,9 +106,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[0].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[0].residual + "' != '" + -26738 + "'", - value.equals(BigInteger.valueOf(-26738L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[0].residual + "' != '" + -26738 + "'", value.equals(BigInteger.valueOf( -26738L ) ) ); } else { value = value.longValue(); expected = -26738L; @@ -384,9 +114,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[0].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[0].stddev + "' != '" + 74 + "'", - value.equals(BigInteger.valueOf(74L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[0].stddev + "' != '" + 74 + "'", value.equals(BigInteger.valueOf( 74L ) ) ); } else { value = value.longValue(); expected = 74L; @@ -394,9 +122,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[0].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[0].sv_id.constellation + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[0].sv_id.constellation + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -404,9 +130,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[0].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[0].sv_id.satId + "' != '" + 87 + "'", - value.equals(BigInteger.valueOf(87L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[0].sv_id.satId + "' != '" + 87 + "'", value.equals(BigInteger.valueOf( 87L ) ) ); } else { value = value.longValue(); expected = 87L; @@ -414,9 +138,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[1].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[1].residual + "' != '" + 1886 + "'", - value.equals(BigInteger.valueOf(1886L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[1].residual + "' != '" + 1886 + "'", value.equals(BigInteger.valueOf( 1886L ) ) ); } else { value = value.longValue(); expected = 1886L; @@ -424,9 +146,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[1].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[1].stddev + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[1].stddev + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -434,9 +154,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[1].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[1].sv_id.constellation + "' != '" + 95 + "'", - value.equals(BigInteger.valueOf(95L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[1].sv_id.constellation + "' != '" + 95 + "'", value.equals(BigInteger.valueOf( 95L ) ) ); } else { value = value.longValue(); expected = 95L; @@ -444,9 +162,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[1].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[1].sv_id.satId + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[1].sv_id.satId + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -454,9 +170,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[2].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[2].residual + "' != '" + 22183 + "'", - value.equals(BigInteger.valueOf(22183L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[2].residual + "' != '" + 22183 + "'", value.equals(BigInteger.valueOf( 22183L ) ) ); } else { value = value.longValue(); expected = 22183L; @@ -464,9 +178,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[2].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[2].stddev + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[2].stddev + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -474,9 +186,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[2].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[2].sv_id.constellation + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[2].sv_id.constellation + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -484,9 +194,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[2].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[2].sv_id.satId + "' != '" + 237 + "'", - value.equals(BigInteger.valueOf(237L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[2].sv_id.satId + "' != '" + 237 + "'", value.equals(BigInteger.valueOf( 237L ) ) ); } else { value = value.longValue(); expected = 237L; @@ -494,9 +202,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[3].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[3].residual + "' != '" + -5463 + "'", - value.equals(BigInteger.valueOf(-5463L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[3].residual + "' != '" + -5463 + "'", value.equals(BigInteger.valueOf( -5463L ) ) ); } else { value = value.longValue(); expected = -5463L; @@ -504,9 +210,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[3].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[3].stddev + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[3].stddev + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -514,9 +218,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[3].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[3].sv_id.constellation + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[3].sv_id.constellation + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -524,9 +226,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[3].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[3].sv_id.satId + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[3].sv_id.satId + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -534,9 +234,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[4].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[4].residual + "' != '" + 3346 + "'", - value.equals(BigInteger.valueOf(3346L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[4].residual + "' != '" + 3346 + "'", value.equals(BigInteger.valueOf( 3346L ) ) ); } else { value = value.longValue(); expected = 3346L; @@ -544,9 +242,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[4].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[4].stddev + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[4].stddev + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -554,9 +250,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[4].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[4].sv_id.constellation + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[4].sv_id.constellation + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -564,9 +258,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[4].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[4].sv_id.satId + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[4].sv_id.satId + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -574,9 +266,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[5].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[5].residual + "' != '" + 28320 + "'", - value.equals(BigInteger.valueOf(28320L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[5].residual + "' != '" + 28320 + "'", value.equals(BigInteger.valueOf( 28320L ) ) ); } else { value = value.longValue(); expected = 28320L; @@ -584,9 +274,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[5].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[5].stddev + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[5].stddev + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -594,9 +282,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[5].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[5].sv_id.constellation + "' != '" + 160 + "'", - value.equals(BigInteger.valueOf(160L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[5].sv_id.constellation + "' != '" + 160 + "'", value.equals(BigInteger.valueOf( 160L ) ) ); } else { value = value.longValue(); expected = 160L; @@ -604,9 +290,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[5].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[5].sv_id.satId + "' != '" + 79 + "'", - value.equals(BigInteger.valueOf(79L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[5].sv_id.satId + "' != '" + 79 + "'", value.equals(BigInteger.valueOf( 79L ) ) ); } else { value = value.longValue(); expected = 79L; @@ -614,9 +298,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[6].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[6].residual + "' != '" + -24937 + "'", - value.equals(BigInteger.valueOf(-24937L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[6].residual + "' != '" + -24937 + "'", value.equals(BigInteger.valueOf( -24937L ) ) ); } else { value = value.longValue(); expected = -24937L; @@ -624,9 +306,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[6].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[6].stddev + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[6].stddev + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -634,9 +314,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[6].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[6].sv_id.constellation + "' != '" + 206 + "'", - value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[6].sv_id.constellation + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; @@ -644,9 +322,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[6].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[6].sv_id.satId + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[6].sv_id.satId + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -654,9 +330,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[7].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[7].residual + "' != '" + -21968 + "'", - value.equals(BigInteger.valueOf(-21968L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[7].residual + "' != '" + -21968 + "'", value.equals(BigInteger.valueOf( -21968L ) ) ); } else { value = value.longValue(); expected = -21968L; @@ -664,9 +338,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[7].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[7].stddev + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[7].stddev + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -674,9 +346,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[7].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[7].sv_id.constellation + "' != '" + 184 + "'", - value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[7].sv_id.constellation + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -684,9 +354,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[7].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[7].sv_id.satId + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[7].sv_id.satId + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -694,9 +362,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[8].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[8].residual + "' != '" + 17786 + "'", - value.equals(BigInteger.valueOf(17786L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[8].residual + "' != '" + 17786 + "'", value.equals(BigInteger.valueOf( 17786L ) ) ); } else { value = value.longValue(); expected = 17786L; @@ -704,9 +370,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[8].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[8].stddev + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[8].stddev + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -714,9 +378,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[8].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[8].sv_id.constellation + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[8].sv_id.constellation + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -724,9 +386,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[8].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[8].sv_id.satId + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[8].sv_id.satId + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -734,9 +394,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[9].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[9].residual + "' != '" + 26689 + "'", - value.equals(BigInteger.valueOf(26689L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[9].residual + "' != '" + 26689 + "'", value.equals(BigInteger.valueOf( 26689L ) ) ); } else { value = value.longValue(); expected = 26689L; @@ -744,9 +402,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[9].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[9].stddev + "' != '" + 244 + "'", - value.equals(BigInteger.valueOf(244L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[9].stddev + "' != '" + 244 + "'", value.equals(BigInteger.valueOf( 244L ) ) ); } else { value = value.longValue(); expected = 244L; @@ -754,9 +410,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[9].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[9].sv_id.constellation + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[9].sv_id.constellation + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -764,9 +418,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[9].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[9].sv_id.satId + "' != '" + 110 + "'", - value.equals(BigInteger.valueOf(110L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[9].sv_id.satId + "' != '" + 110 + "'", value.equals(BigInteger.valueOf( 110L ) ) ); } else { value = value.longValue(); expected = 110L; @@ -774,9 +426,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[10].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[10].residual + "' != '" + 22755 + "'", - value.equals(BigInteger.valueOf(22755L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[10].residual + "' != '" + 22755 + "'", value.equals(BigInteger.valueOf( 22755L ) ) ); } else { value = value.longValue(); expected = 22755L; @@ -784,9 +434,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[10].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[10].stddev + "' != '" + 169 + "'", - value.equals(BigInteger.valueOf(169L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[10].stddev + "' != '" + 169 + "'", value.equals(BigInteger.valueOf( 169L ) ) ); } else { value = value.longValue(); expected = 169L; @@ -794,9 +442,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[10].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[10].sv_id.constellation + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[10].sv_id.constellation + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -804,9 +450,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[10].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[10].sv_id.satId + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[10].sv_id.satId + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -814,9 +458,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[11].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[11].residual + "' != '" + 9535 + "'", - value.equals(BigInteger.valueOf(9535L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[11].residual + "' != '" + 9535 + "'", value.equals(BigInteger.valueOf( 9535L ) ) ); } else { value = value.longValue(); expected = 9535L; @@ -824,9 +466,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[11].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[11].stddev + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[11].stddev + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -834,9 +474,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[11].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[11].sv_id.constellation + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[11].sv_id.constellation + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -844,9 +482,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[11].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[11].sv_id.satId + "' != '" + 164 + "'", - value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[11].sv_id.satId + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -854,9 +490,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[12].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[12].residual + "' != '" + -22293 + "'", - value.equals(BigInteger.valueOf(-22293L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[12].residual + "' != '" + -22293 + "'", value.equals(BigInteger.valueOf( -22293L ) ) ); } else { value = value.longValue(); expected = -22293L; @@ -864,9 +498,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[12].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[12].stddev + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[12].stddev + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -874,9 +506,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[12].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[12].sv_id.constellation + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[12].sv_id.constellation + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -884,9 +514,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[12].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[12].sv_id.satId + "' != '" + 85 + "'", - value.equals(BigInteger.valueOf(85L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[12].sv_id.satId + "' != '" + 85 + "'", value.equals(BigInteger.valueOf( 85L ) ) ); } else { value = value.longValue(); expected = 85L; @@ -894,9 +522,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[13].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[13].residual + "' != '" + -25379 + "'", - value.equals(BigInteger.valueOf(-25379L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[13].residual + "' != '" + -25379 + "'", value.equals(BigInteger.valueOf( -25379L ) ) ); } else { value = value.longValue(); expected = -25379L; @@ -904,9 +530,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[13].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[13].stddev + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[13].stddev + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -914,9 +538,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[13].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[13].sv_id.constellation + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[13].sv_id.constellation + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -924,9 +546,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[13].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[13].sv_id.satId + "' != '" + 211 + "'", - value.equals(BigInteger.valueOf(211L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[13].sv_id.satId + "' != '" + 211 + "'", value.equals(BigInteger.valueOf( 211L ) ) ); } else { value = value.longValue(); expected = 211L; @@ -934,9 +554,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[14].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[14].residual + "' != '" + -29182 + "'", - value.equals(BigInteger.valueOf(-29182L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[14].residual + "' != '" + -29182 + "'", value.equals(BigInteger.valueOf( -29182L ) ) ); } else { value = value.longValue(); expected = -29182L; @@ -944,9 +562,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[14].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[14].stddev + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[14].stddev + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -954,9 +570,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[14].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[14].sv_id.constellation + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[14].sv_id.constellation + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -964,9 +578,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[14].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[14].sv_id.satId + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[14].sv_id.satId + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -974,9 +586,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[15].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[15].residual + "' != '" + 32289 + "'", - value.equals(BigInteger.valueOf(32289L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[15].residual + "' != '" + 32289 + "'", value.equals(BigInteger.valueOf( 32289L ) ) ); } else { value = value.longValue(); expected = 32289L; @@ -984,9 +594,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[15].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[15].stddev + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[15].stddev + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -994,9 +602,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[15].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[15].sv_id.constellation + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[15].sv_id.constellation + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -1004,9 +610,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[15].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[15].sv_id.satId + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[15].sv_id.satId + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -1014,9 +618,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[16].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[16].residual + "' != '" + 10730 + "'", - value.equals(BigInteger.valueOf(10730L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[16].residual + "' != '" + 10730 + "'", value.equals(BigInteger.valueOf( 10730L ) ) ); } else { value = value.longValue(); expected = 10730L; @@ -1024,9 +626,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[16].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[16].stddev + "' != '" + 162 + "'", - value.equals(BigInteger.valueOf(162L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[16].stddev + "' != '" + 162 + "'", value.equals(BigInteger.valueOf( 162L ) ) ); } else { value = value.longValue(); expected = 162L; @@ -1034,9 +634,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[16].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[16].sv_id.constellation + "' != '" + 188 + "'", - value.equals(BigInteger.valueOf(188L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[16].sv_id.constellation + "' != '" + 188 + "'", value.equals(BigInteger.valueOf( 188L ) ) ); } else { value = value.longValue(); expected = 188L; @@ -1044,9 +642,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[16].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[16].sv_id.satId + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[16].sv_id.satId + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -1054,9 +650,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[17].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[17].residual + "' != '" + 20707 + "'", - value.equals(BigInteger.valueOf(20707L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[17].residual + "' != '" + 20707 + "'", value.equals(BigInteger.valueOf( 20707L ) ) ); } else { value = value.longValue(); expected = 20707L; @@ -1064,9 +658,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[17].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[17].stddev + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[17].stddev + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1074,9 +666,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[17].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[17].sv_id.constellation + "' != '" + 138 + "'", - value.equals(BigInteger.valueOf(138L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[17].sv_id.constellation + "' != '" + 138 + "'", value.equals(BigInteger.valueOf( 138L ) ) ); } else { value = value.longValue(); expected = 138L; @@ -1084,9 +674,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[17].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[17].sv_id.satId + "' != '" + 197 + "'", - value.equals(BigInteger.valueOf(197L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[17].sv_id.satId + "' != '" + 197 + "'", value.equals(BigInteger.valueOf( 197L ) ) ); } else { value = value.longValue(); expected = 197L; @@ -1094,9 +682,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[18].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[18].residual + "' != '" + 1518 + "'", - value.equals(BigInteger.valueOf(1518L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[18].residual + "' != '" + 1518 + "'", value.equals(BigInteger.valueOf( 1518L ) ) ); } else { value = value.longValue(); expected = 1518L; @@ -1104,9 +690,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[18].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[18].stddev + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[18].stddev + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -1114,9 +698,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[18].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[18].sv_id.constellation + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[18].sv_id.constellation + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -1124,9 +706,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[18].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[18].sv_id.satId + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[18].sv_id.satId + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -1134,9 +714,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[19].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[19].residual + "' != '" + 3457 + "'", - value.equals(BigInteger.valueOf(3457L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[19].residual + "' != '" + 3457 + "'", value.equals(BigInteger.valueOf( 3457L ) ) ); } else { value = value.longValue(); expected = 3457L; @@ -1144,9 +722,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[19].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[19].stddev + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[19].stddev + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -1154,9 +730,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[19].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[19].sv_id.constellation + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[19].sv_id.constellation + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -1164,9 +738,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[19].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[19].sv_id.satId + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[19].sv_id.satId + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1174,9 +746,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[20].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[20].residual + "' != '" + -18118 + "'", - value.equals(BigInteger.valueOf(-18118L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[20].residual + "' != '" + -18118 + "'", value.equals(BigInteger.valueOf( -18118L ) ) ); } else { value = value.longValue(); expected = -18118L; @@ -1184,9 +754,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[20].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[20].stddev + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[20].stddev + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -1194,9 +762,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[20].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[20].sv_id.constellation + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[20].sv_id.constellation + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -1204,9 +770,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[20].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[20].sv_id.satId + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[20].sv_id.satId + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1214,9 +778,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[21].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[21].residual + "' != '" + -9888 + "'", - value.equals(BigInteger.valueOf(-9888L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[21].residual + "' != '" + -9888 + "'", value.equals(BigInteger.valueOf( -9888L ) ) ); } else { value = value.longValue(); expected = -9888L; @@ -1224,9 +786,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[21].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[21].stddev + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[21].stddev + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -1234,9 +794,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[21].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[21].sv_id.constellation + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[21].sv_id.constellation + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -1244,9 +802,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[21].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[21].sv_id.satId + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[21].sv_id.satId + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -1254,9 +810,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[22].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[22].residual + "' != '" + -14793 + "'", - value.equals(BigInteger.valueOf(-14793L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[22].residual + "' != '" + -14793 + "'", value.equals(BigInteger.valueOf( -14793L ) ) ); } else { value = value.longValue(); expected = -14793L; @@ -1264,9 +818,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[22].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[22].stddev + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[22].stddev + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -1274,9 +826,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[22].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[22].sv_id.constellation + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[22].sv_id.constellation + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -1284,9 +834,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[22].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[22].sv_id.satId + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[22].sv_id.satId + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -1294,9 +842,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[23].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[23].residual + "' != '" + 18758 + "'", - value.equals(BigInteger.valueOf(18758L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[23].residual + "' != '" + 18758 + "'", value.equals(BigInteger.valueOf( 18758L ) ) ); } else { value = value.longValue(); expected = 18758L; @@ -1304,9 +850,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[23].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[23].stddev + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[23].stddev + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -1314,9 +858,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[23].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[23].sv_id.constellation + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[23].sv_id.constellation + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -1324,9 +866,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[23].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[23].sv_id.satId + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[23].sv_id.satId + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -1334,9 +874,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[24].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[24].residual + "' != '" + 3839 + "'", - value.equals(BigInteger.valueOf(3839L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[24].residual + "' != '" + 3839 + "'", value.equals(BigInteger.valueOf( 3839L ) ) ); } else { value = value.longValue(); expected = 3839L; @@ -1344,9 +882,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[24].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[24].stddev + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[24].stddev + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -1354,9 +890,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[24].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[24].sv_id.constellation + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[24].sv_id.constellation + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -1364,9 +898,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[24].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[24].sv_id.satId + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[24].sv_id.satId + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -1374,9 +906,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[25].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[25].residual + "' != '" + -10697 + "'", - value.equals(BigInteger.valueOf(-10697L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[25].residual + "' != '" + -10697 + "'", value.equals(BigInteger.valueOf( -10697L ) ) ); } else { value = value.longValue(); expected = -10697L; @@ -1384,9 +914,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[25].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[25].stddev + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[25].stddev + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -1394,9 +922,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[25].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[25].sv_id.constellation + "' != '" + 138 + "'", - value.equals(BigInteger.valueOf(138L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[25].sv_id.constellation + "' != '" + 138 + "'", value.equals(BigInteger.valueOf( 138L ) ) ); } else { value = value.longValue(); expected = 138L; @@ -1404,9 +930,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[25].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[25].sv_id.satId + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[25].sv_id.satId + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -1414,9 +938,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[26].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[26].residual + "' != '" + 20387 + "'", - value.equals(BigInteger.valueOf(20387L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[26].residual + "' != '" + 20387 + "'", value.equals(BigInteger.valueOf( 20387L ) ) ); } else { value = value.longValue(); expected = 20387L; @@ -1424,9 +946,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[26].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[26].stddev + "' != '" + 173 + "'", - value.equals(BigInteger.valueOf(173L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[26].stddev + "' != '" + 173 + "'", value.equals(BigInteger.valueOf( 173L ) ) ); } else { value = value.longValue(); expected = 173L; @@ -1434,9 +954,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[26].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[26].sv_id.constellation + "' != '" + 170 + "'", - value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[26].sv_id.constellation + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -1444,9 +962,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[26].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[26].sv_id.satId + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[26].sv_id.satId + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -1454,9 +970,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[27].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[27].residual + "' != '" + -3789 + "'", - value.equals(BigInteger.valueOf(-3789L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[27].residual + "' != '" + -3789 + "'", value.equals(BigInteger.valueOf( -3789L ) ) ); } else { value = value.longValue(); expected = -3789L; @@ -1464,9 +978,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[27].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[27].stddev + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[27].stddev + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -1474,9 +986,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[27].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[27].sv_id.constellation + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[27].sv_id.constellation + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1484,9 +994,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[27].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[27].sv_id.satId + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[27].sv_id.satId + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -1494,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[28].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[28].residual + "' != '" + -11608 + "'", - value.equals(BigInteger.valueOf(-11608L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[28].residual + "' != '" + -11608 + "'", value.equals(BigInteger.valueOf( -11608L ) ) ); } else { value = value.longValue(); expected = -11608L; @@ -1504,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[28].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[28].stddev + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[28].stddev + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -1514,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[28].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[28].sv_id.constellation + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[28].sv_id.constellation + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -1524,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[28].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[28].sv_id.satId + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[28].sv_id.satId + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -1534,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[29].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[29].residual + "' != '" + 14593 + "'", - value.equals(BigInteger.valueOf(14593L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[29].residual + "' != '" + 14593 + "'", value.equals(BigInteger.valueOf( 14593L ) ) ); } else { value = value.longValue(); expected = 14593L; @@ -1544,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[29].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[29].stddev + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[29].stddev + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -1554,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[29].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[29].sv_id.constellation + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[29].sv_id.constellation + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -1564,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[29].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[29].sv_id.satId + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[29].sv_id.satId + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -1574,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[30].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[30].residual + "' != '" + 30609 + "'", - value.equals(BigInteger.valueOf(30609L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[30].residual + "' != '" + 30609 + "'", value.equals(BigInteger.valueOf( 30609L ) ) ); } else { value = value.longValue(); expected = 30609L; @@ -1584,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[30].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[30].stddev + "' != '" + 226 + "'", - value.equals(BigInteger.valueOf(226L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[30].stddev + "' != '" + 226 + "'", value.equals(BigInteger.valueOf( 226L ) ) ); } else { value = value.longValue(); expected = 226L; @@ -1594,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[30].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[30].sv_id.constellation + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[30].sv_id.constellation + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -1604,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[30].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[30].sv_id.satId + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[30].sv_id.satId + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -1614,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[31].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[31].residual + "' != '" + -13683 + "'", - value.equals(BigInteger.valueOf(-13683L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[31].residual + "' != '" + -13683 + "'", value.equals(BigInteger.valueOf( -13683L ) ) ); } else { value = value.longValue(); expected = -13683L; @@ -1624,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[31].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[31].stddev + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[31].stddev + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -1634,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[31].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[31].sv_id.constellation + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[31].sv_id.constellation + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -1644,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[31].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[31].sv_id.satId + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[31].sv_id.satId + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -1654,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[32].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[32].residual + "' != '" + 15652 + "'", - value.equals(BigInteger.valueOf(15652L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[32].residual + "' != '" + 15652 + "'", value.equals(BigInteger.valueOf( 15652L ) ) ); } else { value = value.longValue(); expected = 15652L; @@ -1664,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[32].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[32].stddev + "' != '" + 243 + "'", - value.equals(BigInteger.valueOf(243L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[32].stddev + "' != '" + 243 + "'", value.equals(BigInteger.valueOf( 243L ) ) ); } else { value = value.longValue(); expected = 243L; @@ -1674,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[32].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[32].sv_id.constellation + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[32].sv_id.constellation + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -1684,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[32].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[32].sv_id.satId + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[32].sv_id.satId + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1694,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[33].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[33].residual + "' != '" + 3287 + "'", - value.equals(BigInteger.valueOf(3287L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[33].residual + "' != '" + 3287 + "'", value.equals(BigInteger.valueOf( 3287L ) ) ); } else { value = value.longValue(); expected = 3287L; @@ -1704,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[33].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[33].stddev + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[33].stddev + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -1714,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[33].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[33].sv_id.constellation + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[33].sv_id.constellation + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -1724,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[33].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[33].sv_id.satId + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[33].sv_id.satId + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -1734,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[34].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[34].residual + "' != '" + 29687 + "'", - value.equals(BigInteger.valueOf(29687L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[34].residual + "' != '" + 29687 + "'", value.equals(BigInteger.valueOf( 29687L ) ) ); } else { value = value.longValue(); expected = 29687L; @@ -1744,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[34].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[34].stddev + "' != '" + 152 + "'", - value.equals(BigInteger.valueOf(152L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[34].stddev + "' != '" + 152 + "'", value.equals(BigInteger.valueOf( 152L ) ) ); } else { value = value.longValue(); expected = 152L; @@ -1754,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[34].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[34].sv_id.constellation + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[34].sv_id.constellation + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -1764,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[34].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[34].sv_id.satId + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[34].sv_id.satId + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -1774,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[35].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[35].residual + "' != '" + -6960 + "'", - value.equals(BigInteger.valueOf(-6960L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[35].residual + "' != '" + -6960 + "'", value.equals(BigInteger.valueOf( -6960L ) ) ); } else { value = value.longValue(); expected = -6960L; @@ -1784,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[35].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[35].stddev + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[35].stddev + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -1794,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[35].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[35].sv_id.constellation + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[35].sv_id.constellation + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -1804,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[35].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[35].sv_id.satId + "' != '" + 181 + "'", - value.equals(BigInteger.valueOf(181L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[35].sv_id.satId + "' != '" + 181 + "'", value.equals(BigInteger.valueOf( 181L ) ) ); } else { value = value.longValue(); expected = 181L; @@ -1814,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[36].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[36].residual + "' != '" + -15193 + "'", - value.equals(BigInteger.valueOf(-15193L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[36].residual + "' != '" + -15193 + "'", value.equals(BigInteger.valueOf( -15193L ) ) ); } else { value = value.longValue(); expected = -15193L; @@ -1824,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[36].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[36].stddev + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[36].stddev + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -1834,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[36].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[36].sv_id.constellation + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[36].sv_id.constellation + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -1844,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[36].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[36].sv_id.satId + "' != '" + 236 + "'", - value.equals(BigInteger.valueOf(236L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[36].sv_id.satId + "' != '" + 236 + "'", value.equals(BigInteger.valueOf( 236L ) ) ); } else { value = value.longValue(); expected = 236L; @@ -1854,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[37].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[37].residual + "' != '" + 25873 + "'", - value.equals(BigInteger.valueOf(25873L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[37].residual + "' != '" + 25873 + "'", value.equals(BigInteger.valueOf( 25873L ) ) ); } else { value = value.longValue(); expected = 25873L; @@ -1864,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[37].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[37].stddev + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[37].stddev + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -1874,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[37].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[37].sv_id.constellation + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[37].sv_id.constellation + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1884,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[37].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[37].sv_id.satId + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[37].sv_id.satId + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -1894,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[38].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[38].residual + "' != '" + -22403 + "'", - value.equals(BigInteger.valueOf(-22403L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[38].residual + "' != '" + -22403 + "'", value.equals(BigInteger.valueOf( -22403L ) ) ); } else { value = value.longValue(); expected = -22403L; @@ -1904,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[38].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[38].stddev + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[38].stddev + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -1914,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[38].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[38].sv_id.constellation + "' != '" + 94 + "'", - value.equals(BigInteger.valueOf(94L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[38].sv_id.constellation + "' != '" + 94 + "'", value.equals(BigInteger.valueOf( 94L ) ) ); } else { value = value.longValue(); expected = 94L; @@ -1924,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[38].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[38].sv_id.satId + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[38].sv_id.satId + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -1934,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[39].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[39].residual + "' != '" + 7588 + "'", - value.equals(BigInteger.valueOf(7588L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[39].residual + "' != '" + 7588 + "'", value.equals(BigInteger.valueOf( 7588L ) ) ); } else { value = value.longValue(); expected = 7588L; @@ -1944,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[39].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[39].stddev + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[39].stddev + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -1954,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[39].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[39].sv_id.constellation + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[39].sv_id.constellation + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1964,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[39].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[39].sv_id.satId + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[39].sv_id.satId + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -1974,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[40].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[40].residual + "' != '" + -6840 + "'", - value.equals(BigInteger.valueOf(-6840L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[40].residual + "' != '" + -6840 + "'", value.equals(BigInteger.valueOf( -6840L ) ) ); } else { value = value.longValue(); expected = -6840L; @@ -1984,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[40].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[40].stddev + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[40].stddev + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -1994,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[40].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[40].sv_id.constellation + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[40].sv_id.constellation + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -2004,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[40].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[40].sv_id.satId + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[40].sv_id.satId + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -2014,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[41].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[41].residual + "' != '" + -31412 + "'", - value.equals(BigInteger.valueOf(-31412L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[41].residual + "' != '" + -31412 + "'", value.equals(BigInteger.valueOf( -31412L ) ) ); } else { value = value.longValue(); expected = -31412L; @@ -2024,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[41].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[41].stddev + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[41].stddev + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -2034,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[41].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[41].sv_id.constellation + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[41].sv_id.constellation + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -2044,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[41].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[41].sv_id.satId + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[41].sv_id.satId + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -2054,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[42].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[42].residual + "' != '" + -23413 + "'", - value.equals(BigInteger.valueOf(-23413L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[42].residual + "' != '" + -23413 + "'", value.equals(BigInteger.valueOf( -23413L ) ) ); } else { value = value.longValue(); expected = -23413L; @@ -2064,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[42].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[42].stddev + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[42].stddev + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -2074,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[42].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[42].sv_id.constellation + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[42].sv_id.constellation + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -2084,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[42].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[42].sv_id.satId + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[42].sv_id.satId + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2094,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[43].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[43].residual + "' != '" + 30934 + "'", - value.equals(BigInteger.valueOf(30934L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[43].residual + "' != '" + 30934 + "'", value.equals(BigInteger.valueOf( 30934L ) ) ); } else { value = value.longValue(); expected = 30934L; @@ -2104,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[43].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[43].stddev + "' != '" + 177 + "'", - value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[43].stddev + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -2114,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[43].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[43].sv_id.constellation + "' != '" + 149 + "'", - value.equals(BigInteger.valueOf(149L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[43].sv_id.constellation + "' != '" + 149 + "'", value.equals(BigInteger.valueOf( 149L ) ) ); } else { value = value.longValue(); expected = 149L; @@ -2124,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[43].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[43].sv_id.satId + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[43].sv_id.satId + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -2134,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[44].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[44].residual + "' != '" + 26960 + "'", - value.equals(BigInteger.valueOf(26960L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[44].residual + "' != '" + 26960 + "'", value.equals(BigInteger.valueOf( 26960L ) ) ); } else { value = value.longValue(); expected = 26960L; @@ -2144,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[44].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[44].stddev + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[44].stddev + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -2154,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[44].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[44].sv_id.constellation + "' != '" + 80 + "'", - value.equals(BigInteger.valueOf(80L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[44].sv_id.constellation + "' != '" + 80 + "'", value.equals(BigInteger.valueOf( 80L ) ) ); } else { value = value.longValue(); expected = 80L; @@ -2164,9 +1538,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[44].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[44].sv_id.satId + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[44].sv_id.satId + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -2174,9 +1546,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[45].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[45].residual + "' != '" + 11853 + "'", - value.equals(BigInteger.valueOf(11853L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[45].residual + "' != '" + 11853 + "'", value.equals(BigInteger.valueOf( 11853L ) ) ); } else { value = value.longValue(); expected = 11853L; @@ -2184,9 +1554,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[45].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[45].stddev + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[45].stddev + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -2194,9 +1562,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[45].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[45].sv_id.constellation + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[45].sv_id.constellation + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -2204,9 +1570,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[45].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[45].sv_id.satId + "' != '" + 136 + "'", - value.equals(BigInteger.valueOf(136L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[45].sv_id.satId + "' != '" + 136 + "'", value.equals(BigInteger.valueOf( 136L ) ) ); } else { value = value.longValue(); expected = 136L; @@ -2214,9 +1578,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[46].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[46].residual + "' != '" + -25077 + "'", - value.equals(BigInteger.valueOf(-25077L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[46].residual + "' != '" + -25077 + "'", value.equals(BigInteger.valueOf( -25077L ) ) ); } else { value = value.longValue(); expected = -25077L; @@ -2224,9 +1586,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[46].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[46].stddev + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[46].stddev + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -2234,9 +1594,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[46].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[46].sv_id.constellation + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[46].sv_id.constellation + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -2244,9 +1602,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[46].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[46].sv_id.satId + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[46].sv_id.satId + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -2254,9 +1610,7 @@ public void test1() throws Throwable { } value = msg.tropo_delay_correction.hydro; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.hydro + "' != '" + 10643 + "'", - value.equals(BigInteger.valueOf(10643L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.hydro + "' != '" + 10643 + "'", value.equals(BigInteger.valueOf( 10643L ) ) ); } else { value = value.longValue(); expected = 10643L; @@ -2264,9 +1618,7 @@ public void test1() throws Throwable { } value = msg.tropo_delay_correction.stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.stddev + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.stddev + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -2274,9 +1626,7 @@ public void test1() throws Throwable { } value = msg.tropo_delay_correction.wet; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.wet + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.wet + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionNoStdDepATest.java b/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionNoStdDepATest.java index eebfbf516..9a7d0d458 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionNoStdDepATest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionNoStdDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionNoStdDepA.yaml by generate.py. Do -// not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrectionNoStdDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrectionNoStdDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrGriddedCorrectionNoStdDepATest { @@ -29,275 +33,16 @@ public class auto_check_sbp_ssr_MsgSsrGriddedCorrectionNoStdDepATest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_ssr_MsgSsrGriddedCorrectionNoStdDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 179, - (byte) 240, - (byte) 33, - (byte) 169, - (byte) 236, - (byte) 34, - (byte) 117, - (byte) 245, - (byte) 67, - (byte) 248, - (byte) 233, - (byte) 236, - (byte) 230, - (byte) 230, - (byte) 103, - (byte) 122, - (byte) 63, - (byte) 101, - (byte) 231, - (byte) 157, - (byte) 115, - (byte) 162, - (byte) 197, - (byte) 146, - (byte) 35, - (byte) 107, - (byte) 222, - (byte) 109, - (byte) 52, - (byte) 41, - (byte) 86, - (byte) 12, - (byte) 237, - (byte) 184, - (byte) 65, - (byte) 204, - (byte) 137, - (byte) 148, - (byte) 171, - (byte) 183, - (byte) 11, - (byte) 0, - (byte) 180, - (byte) 203, - (byte) 172, - (byte) 53, - (byte) 196, - (byte) 85, - (byte) 186, - (byte) 115, - (byte) 203, - (byte) 92, - (byte) 166, - (byte) 30, - (byte) 42, - (byte) 13, - (byte) 200, - (byte) 71, - (byte) 98, - (byte) 137, - (byte) 219, - (byte) 160, - (byte) 95, - (byte) 216, - (byte) 95, - (byte) 250, - (byte) 99, - (byte) 196, - (byte) 92, - (byte) 214, - (byte) 159, - (byte) 253, - (byte) 195, - (byte) 222, - (byte) 233, - (byte) 146, - (byte) 233, - (byte) 63, - (byte) 76, - (byte) 24, - (byte) 106, - (byte) 40, - (byte) 253, - (byte) 65, - (byte) 9, - (byte) 183, - (byte) 40, - (byte) 215, - (byte) 188, - (byte) 59, - (byte) 117, - (byte) 69, - (byte) 97, - (byte) 115, - (byte) 60, - (byte) 56, - (byte) 0, - (byte) 141, - (byte) 207, - (byte) 171, - (byte) 54, - (byte) 161, - (byte) 23, - (byte) 61, - (byte) 0, - (byte) 87, - (byte) 230, - (byte) 123, - (byte) 87, - (byte) 36, - (byte) 184, - (byte) 255, - (byte) 14, - (byte) 163, - (byte) 187, - (byte) 224, - (byte) 43, - (byte) 151, - (byte) 151, - (byte) 104, - (byte) 39, - (byte) 57, - (byte) 5, - (byte) 54, - (byte) 48, - (byte) 224, - (byte) 181, - (byte) 129, - (byte) 60, - (byte) 92, - (byte) 171, - (byte) 114, - (byte) 109, - (byte) 109, - (byte) 12, - (byte) 23, - (byte) 118, - (byte) 8, - (byte) 64, - (byte) 159, - (byte) 54, - (byte) 216, - (byte) 33, - (byte) 20, - (byte) 24, - (byte) 68, - (byte) 160, - (byte) 36, - (byte) 38, - (byte) 222, - (byte) 145, - (byte) 190, - (byte) 92, - (byte) 99, - (byte) 108, - (byte) 159, - (byte) 232, - (byte) 240, - (byte) 227, - (byte) 221, - (byte) 253, - (byte) 15, - (byte) 62, - (byte) 23, - (byte) 121, - (byte) 185, - (byte) 168, - (byte) 116, - (byte) 4, - (byte) 147, - (byte) 123, - (byte) 72, - (byte) 223, - (byte) 119, - (byte) 226, - (byte) 242, - (byte) 161, - (byte) 204, - (byte) 180, - (byte) 202, - (byte) 137, - (byte) 166, - (byte) 58, - (byte) 24, - (byte) 124, - (byte) 19, - (byte) 181, - (byte) 188, - (byte) 16, - (byte) 107, - (byte) 66, - (byte) 231, - (byte) 63, - (byte) 1, - (byte) 64, - (byte) 252, - (byte) 115, - (byte) 62, - (byte) 233, - (byte) 97, - (byte) 250, - (byte) 86, - (byte) 156, - (byte) 221, - (byte) 49, - (byte) 178, - (byte) 32, - (byte) 73, - (byte) 198, - (byte) 67, - (byte) 249, - (byte) 253, - (byte) 74, - (byte) 56, - (byte) 38, - (byte) 165, - (byte) 119, - (byte) 92, - (byte) 99, - (byte) 44, - (byte) 95, - (byte) 131, - (byte) 89, - (byte) 192, - (byte) 225, - (byte) 55, - (byte) 95, - (byte) 171, - (byte) 88, - (byte) 205, - (byte) 21, - (byte) 116, - (byte) 231, - (byte) 83, - (byte) 71, - (byte) 71, - (byte) 100, - (byte) 110, - (byte) 217, - (byte) 254, - (byte) 152, - (byte) 212, - (byte) 18, - (byte) 8, - (byte) 40, - (byte) 157, - (byte) 244, - (byte) 54, - (byte) 72, - (byte) 240, - (byte) 231, - (byte) 189, - (byte) 111, - (byte) 195, - }; - SBPMessage sbp = new SBPMessage(0x1c66, 0x5f0, payload); - MsgSsrGriddedCorrectionNoStdDepA msg = new MsgSsrGriddedCorrectionNoStdDepA(sbp); + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrGriddedCorrectionNoStdDepATest.test1"); + byte[] payload = new byte[] {(byte)179,(byte)240,(byte)33,(byte)169,(byte)236,(byte)34,(byte)117,(byte)245,(byte)67,(byte)248,(byte)233,(byte)236,(byte)230,(byte)230,(byte)103,(byte)122,(byte)63,(byte)101,(byte)231,(byte)157,(byte)115,(byte)162,(byte)197,(byte)146,(byte)35,(byte)107,(byte)222,(byte)109,(byte)52,(byte)41,(byte)86,(byte)12,(byte)237,(byte)184,(byte)65,(byte)204,(byte)137,(byte)148,(byte)171,(byte)183,(byte)11,(byte)0,(byte)180,(byte)203,(byte)172,(byte)53,(byte)196,(byte)85,(byte)186,(byte)115,(byte)203,(byte)92,(byte)166,(byte)30,(byte)42,(byte)13,(byte)200,(byte)71,(byte)98,(byte)137,(byte)219,(byte)160,(byte)95,(byte)216,(byte)95,(byte)250,(byte)99,(byte)196,(byte)92,(byte)214,(byte)159,(byte)253,(byte)195,(byte)222,(byte)233,(byte)146,(byte)233,(byte)63,(byte)76,(byte)24,(byte)106,(byte)40,(byte)253,(byte)65,(byte)9,(byte)183,(byte)40,(byte)215,(byte)188,(byte)59,(byte)117,(byte)69,(byte)97,(byte)115,(byte)60,(byte)56,(byte)0,(byte)141,(byte)207,(byte)171,(byte)54,(byte)161,(byte)23,(byte)61,(byte)0,(byte)87,(byte)230,(byte)123,(byte)87,(byte)36,(byte)184,(byte)255,(byte)14,(byte)163,(byte)187,(byte)224,(byte)43,(byte)151,(byte)151,(byte)104,(byte)39,(byte)57,(byte)5,(byte)54,(byte)48,(byte)224,(byte)181,(byte)129,(byte)60,(byte)92,(byte)171,(byte)114,(byte)109,(byte)109,(byte)12,(byte)23,(byte)118,(byte)8,(byte)64,(byte)159,(byte)54,(byte)216,(byte)33,(byte)20,(byte)24,(byte)68,(byte)160,(byte)36,(byte)38,(byte)222,(byte)145,(byte)190,(byte)92,(byte)99,(byte)108,(byte)159,(byte)232,(byte)240,(byte)227,(byte)221,(byte)253,(byte)15,(byte)62,(byte)23,(byte)121,(byte)185,(byte)168,(byte)116,(byte)4,(byte)147,(byte)123,(byte)72,(byte)223,(byte)119,(byte)226,(byte)242,(byte)161,(byte)204,(byte)180,(byte)202,(byte)137,(byte)166,(byte)58,(byte)24,(byte)124,(byte)19,(byte)181,(byte)188,(byte)16,(byte)107,(byte)66,(byte)231,(byte)63,(byte)1,(byte)64,(byte)252,(byte)115,(byte)62,(byte)233,(byte)97,(byte)250,(byte)86,(byte)156,(byte)221,(byte)49,(byte)178,(byte)32,(byte)73,(byte)198,(byte)67,(byte)249,(byte)253,(byte)74,(byte)56,(byte)38,(byte)165,(byte)119,(byte)92,(byte)99,(byte)44,(byte)95,(byte)131,(byte)89,(byte)192,(byte)225,(byte)55,(byte)95,(byte)171,(byte)88,(byte)205,(byte)21,(byte)116,(byte)231,(byte)83,(byte)71,(byte)71,(byte)100,(byte)110,(byte)217,(byte)254,(byte)152,(byte)212,(byte)18,(byte)8,(byte)40,(byte)157,(byte)244,(byte)54,(byte)72,(byte)240,(byte)231,(byte)189,(byte)111,(byte)195, }; + SBPMessage sbp = new SBPMessage( 0x1c66, 0x5f0, payload ); + MsgSsrGriddedCorrectionNoStdDepA msg = new MsgSsrGriddedCorrectionNoStdDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.header.iod_atmo; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.iod_atmo + "' != '" + 236 + "'", - value.equals(BigInteger.valueOf(236L))); + org.junit.Assert.assertTrue("'" + msg.header.iod_atmo + "' != '" + 236 + "'", value.equals(BigInteger.valueOf( 236L ) ) ); } else { value = value.longValue(); expected = 236L; @@ -305,9 +50,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 62837 + "'", - value.equals(BigInteger.valueOf(62837L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 62837 + "'", value.equals(BigInteger.valueOf( 62837L ) ) ); } else { value = value.longValue(); expected = 62837L; @@ -315,9 +58,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 63555 + "'", - value.equals(BigInteger.valueOf(63555L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 63555 + "'", value.equals(BigInteger.valueOf( 63555L ) ) ); } else { value = value.longValue(); expected = 63555L; @@ -325,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.tow + "' != '" + 2837573811L + "'", - value.equals(new BigInteger("2837573811"))); + org.junit.Assert.assertTrue("'" + msg.header.time.tow + "' != '" + 2837573811L + "'", value.equals( new BigInteger( "2837573811" ) ) ); } else { value = value.longValue(); expected = 2837573811L; @@ -335,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.wn + "' != '" + 8940 + "'", - value.equals(BigInteger.valueOf(8940L))); + org.junit.Assert.assertTrue("'" + msg.header.time.wn + "' != '" + 8940 + "'", value.equals(BigInteger.valueOf( 8940L ) ) ); } else { value = value.longValue(); expected = 8940L; @@ -345,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.tropo_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tropo_quality_indicator + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.header.tropo_quality_indicator + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -355,9 +90,7 @@ public void test1() throws Throwable { } value = msg.header.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.update_interval + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.header.update_interval + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -365,9 +98,7 @@ public void test1() throws Throwable { } value = msg.index; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.index + "' != '" + 26598 + "'", - value.equals(BigInteger.valueOf(26598L))); + org.junit.Assert.assertTrue("'" + msg.index + "' != '" + 26598 + "'", value.equals(BigInteger.valueOf( 26598L ) ) ); } else { value = value.longValue(); expected = 26598L; @@ -375,9 +106,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[0].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[0].residual + "' != '" + -23949 + "'", - value.equals(BigInteger.valueOf(-23949L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[0].residual + "' != '" + -23949 + "'", value.equals(BigInteger.valueOf( -23949L ) ) ); } else { value = value.longValue(); expected = -23949L; @@ -385,9 +114,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[0].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[0].sv_id.constellation + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[0].sv_id.constellation + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -395,9 +122,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[0].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[0].sv_id.satId + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[0].sv_id.satId + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -405,9 +130,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[1].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[1].residual + "' != '" + 27427 + "'", - value.equals(BigInteger.valueOf(27427L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[1].residual + "' != '" + 27427 + "'", value.equals(BigInteger.valueOf( 27427L ) ) ); } else { value = value.longValue(); expected = 27427L; @@ -415,9 +138,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[1].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[1].sv_id.constellation + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[1].sv_id.constellation + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -425,9 +146,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[1].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[1].sv_id.satId + "' != '" + 197 + "'", - value.equals(BigInteger.valueOf(197L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[1].sv_id.satId + "' != '" + 197 + "'", value.equals(BigInteger.valueOf( 197L ) ) ); } else { value = value.longValue(); expected = 197L; @@ -435,9 +154,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[2].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[2].residual + "' != '" + 10548 + "'", - value.equals(BigInteger.valueOf(10548L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[2].residual + "' != '" + 10548 + "'", value.equals(BigInteger.valueOf( 10548L ) ) ); } else { value = value.longValue(); expected = 10548L; @@ -445,9 +162,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[2].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[2].sv_id.constellation + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[2].sv_id.constellation + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -455,9 +170,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[2].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[2].sv_id.satId + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[2].sv_id.satId + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -465,9 +178,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[3].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[3].residual + "' != '" + -18195 + "'", - value.equals(BigInteger.valueOf(-18195L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[3].residual + "' != '" + -18195 + "'", value.equals(BigInteger.valueOf( -18195L ) ) ); } else { value = value.longValue(); expected = -18195L; @@ -475,9 +186,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[3].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[3].sv_id.constellation + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[3].sv_id.constellation + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -485,9 +194,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[3].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[3].sv_id.satId + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[3].sv_id.satId + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -495,9 +202,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[4].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[4].residual + "' != '" + -27511 + "'", - value.equals(BigInteger.valueOf(-27511L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[4].residual + "' != '" + -27511 + "'", value.equals(BigInteger.valueOf( -27511L ) ) ); } else { value = value.longValue(); expected = -27511L; @@ -505,9 +210,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[4].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[4].sv_id.constellation + "' != '" + 204 + "'", - value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[4].sv_id.constellation + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -515,9 +218,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[4].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[4].sv_id.satId + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[4].sv_id.satId + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -525,9 +226,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[5].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[5].residual + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[5].residual + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -535,9 +234,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[5].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[5].sv_id.constellation + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[5].sv_id.constellation + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -545,9 +242,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[5].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[5].sv_id.satId + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[5].sv_id.satId + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -555,9 +250,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[6].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[6].residual + "' != '" + 13740 + "'", - value.equals(BigInteger.valueOf(13740L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[6].residual + "' != '" + 13740 + "'", value.equals(BigInteger.valueOf( 13740L ) ) ); } else { value = value.longValue(); expected = 13740L; @@ -565,9 +258,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[6].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[6].sv_id.constellation + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[6].sv_id.constellation + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -575,9 +266,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[6].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[6].sv_id.satId + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[6].sv_id.satId + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -585,9 +274,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[7].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[7].residual + "' != '" + 29626 + "'", - value.equals(BigInteger.valueOf(29626L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[7].residual + "' != '" + 29626 + "'", value.equals(BigInteger.valueOf( 29626L ) ) ); } else { value = value.longValue(); expected = 29626L; @@ -595,9 +282,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[7].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[7].sv_id.constellation + "' != '" + 85 + "'", - value.equals(BigInteger.valueOf(85L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[7].sv_id.constellation + "' != '" + 85 + "'", value.equals(BigInteger.valueOf( 85L ) ) ); } else { value = value.longValue(); expected = 85L; @@ -605,9 +290,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[7].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[7].sv_id.satId + "' != '" + 196 + "'", - value.equals(BigInteger.valueOf(196L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[7].sv_id.satId + "' != '" + 196 + "'", value.equals(BigInteger.valueOf( 196L ) ) ); } else { value = value.longValue(); expected = 196L; @@ -615,9 +298,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[8].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[8].residual + "' != '" + 7846 + "'", - value.equals(BigInteger.valueOf(7846L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[8].residual + "' != '" + 7846 + "'", value.equals(BigInteger.valueOf( 7846L ) ) ); } else { value = value.longValue(); expected = 7846L; @@ -625,9 +306,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[8].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[8].sv_id.constellation + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[8].sv_id.constellation + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -635,9 +314,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[8].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[8].sv_id.satId + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[8].sv_id.satId + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -645,9 +322,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[9].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[9].residual + "' != '" + 18376 + "'", - value.equals(BigInteger.valueOf(18376L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[9].residual + "' != '" + 18376 + "'", value.equals(BigInteger.valueOf( 18376L ) ) ); } else { value = value.longValue(); expected = 18376L; @@ -655,9 +330,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[9].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[9].sv_id.constellation + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[9].sv_id.constellation + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -665,9 +338,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[9].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[9].sv_id.satId + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[9].sv_id.satId + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -675,9 +346,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[10].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[10].residual + "' != '" + -24357 + "'", - value.equals(BigInteger.valueOf(-24357L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[10].residual + "' != '" + -24357 + "'", value.equals(BigInteger.valueOf( -24357L ) ) ); } else { value = value.longValue(); expected = -24357L; @@ -685,9 +354,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[10].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[10].sv_id.constellation + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[10].sv_id.constellation + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -695,9 +362,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[10].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[10].sv_id.satId + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[10].sv_id.satId + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -705,9 +370,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[11].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[11].residual + "' != '" + -1441 + "'", - value.equals(BigInteger.valueOf(-1441L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[11].residual + "' != '" + -1441 + "'", value.equals(BigInteger.valueOf( -1441L ) ) ); } else { value = value.longValue(); expected = -1441L; @@ -715,9 +378,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[11].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[11].sv_id.constellation + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[11].sv_id.constellation + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -725,9 +386,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[11].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[11].sv_id.satId + "' != '" + 95 + "'", - value.equals(BigInteger.valueOf(95L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[11].sv_id.satId + "' != '" + 95 + "'", value.equals(BigInteger.valueOf( 95L ) ) ); } else { value = value.longValue(); expected = 95L; @@ -735,9 +394,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[12].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[12].residual + "' != '" + -10660 + "'", - value.equals(BigInteger.valueOf(-10660L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[12].residual + "' != '" + -10660 + "'", value.equals(BigInteger.valueOf( -10660L ) ) ); } else { value = value.longValue(); expected = -10660L; @@ -745,9 +402,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[12].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[12].sv_id.constellation + "' != '" + 196 + "'", - value.equals(BigInteger.valueOf(196L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[12].sv_id.constellation + "' != '" + 196 + "'", value.equals(BigInteger.valueOf( 196L ) ) ); } else { value = value.longValue(); expected = 196L; @@ -755,9 +410,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[12].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[12].sv_id.satId + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[12].sv_id.satId + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -765,9 +418,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[13].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[13].residual + "' != '" + -8509 + "'", - value.equals(BigInteger.valueOf(-8509L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[13].residual + "' != '" + -8509 + "'", value.equals(BigInteger.valueOf( -8509L ) ) ); } else { value = value.longValue(); expected = -8509L; @@ -775,9 +426,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[13].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[13].sv_id.constellation + "' != '" + 253 + "'", - value.equals(BigInteger.valueOf(253L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[13].sv_id.constellation + "' != '" + 253 + "'", value.equals(BigInteger.valueOf( 253L ) ) ); } else { value = value.longValue(); expected = 253L; @@ -785,9 +434,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[13].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[13].sv_id.satId + "' != '" + 159 + "'", - value.equals(BigInteger.valueOf(159L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[13].sv_id.satId + "' != '" + 159 + "'", value.equals(BigInteger.valueOf( 159L ) ) ); } else { value = value.longValue(); expected = 159L; @@ -795,9 +442,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[14].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[14].residual + "' != '" + 16361 + "'", - value.equals(BigInteger.valueOf(16361L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[14].residual + "' != '" + 16361 + "'", value.equals(BigInteger.valueOf( 16361L ) ) ); } else { value = value.longValue(); expected = 16361L; @@ -805,9 +450,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[14].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[14].sv_id.constellation + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[14].sv_id.constellation + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -815,9 +458,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[14].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[14].sv_id.satId + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[14].sv_id.satId + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -825,9 +466,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[15].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[15].residual + "' != '" + 10346 + "'", - value.equals(BigInteger.valueOf(10346L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[15].residual + "' != '" + 10346 + "'", value.equals(BigInteger.valueOf( 10346L ) ) ); } else { value = value.longValue(); expected = 10346L; @@ -835,9 +474,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[15].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[15].sv_id.constellation + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[15].sv_id.constellation + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -845,9 +482,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[15].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[15].sv_id.satId + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[15].sv_id.satId + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -855,9 +490,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[16].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[16].residual + "' != '" + -18679 + "'", - value.equals(BigInteger.valueOf(-18679L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[16].residual + "' != '" + -18679 + "'", value.equals(BigInteger.valueOf( -18679L ) ) ); } else { value = value.longValue(); expected = -18679L; @@ -865,9 +498,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[16].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[16].sv_id.constellation + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[16].sv_id.constellation + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -875,9 +506,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[16].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[16].sv_id.satId + "' != '" + 253 + "'", - value.equals(BigInteger.valueOf(253L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[16].sv_id.satId + "' != '" + 253 + "'", value.equals(BigInteger.valueOf( 253L ) ) ); } else { value = value.longValue(); expected = 253L; @@ -885,9 +514,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[17].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[17].residual + "' != '" + 15292 + "'", - value.equals(BigInteger.valueOf(15292L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[17].residual + "' != '" + 15292 + "'", value.equals(BigInteger.valueOf( 15292L ) ) ); } else { value = value.longValue(); expected = 15292L; @@ -895,9 +522,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[17].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[17].sv_id.constellation + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[17].sv_id.constellation + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -905,9 +530,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[17].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[17].sv_id.satId + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[17].sv_id.satId + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -915,9 +538,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[18].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[18].residual + "' != '" + 29537 + "'", - value.equals(BigInteger.valueOf(29537L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[18].residual + "' != '" + 29537 + "'", value.equals(BigInteger.valueOf( 29537L ) ) ); } else { value = value.longValue(); expected = 29537L; @@ -925,9 +546,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[18].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[18].sv_id.constellation + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[18].sv_id.constellation + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -935,9 +554,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[18].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[18].sv_id.satId + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[18].sv_id.satId + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -945,9 +562,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[19].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[19].residual + "' != '" + -29440 + "'", - value.equals(BigInteger.valueOf(-29440L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[19].residual + "' != '" + -29440 + "'", value.equals(BigInteger.valueOf( -29440L ) ) ); } else { value = value.longValue(); expected = -29440L; @@ -955,9 +570,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[19].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[19].sv_id.constellation + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[19].sv_id.constellation + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -965,9 +578,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[19].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[19].sv_id.satId + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[19].sv_id.satId + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -975,9 +586,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[20].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[20].residual + "' != '" + -24266 + "'", - value.equals(BigInteger.valueOf(-24266L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[20].residual + "' != '" + -24266 + "'", value.equals(BigInteger.valueOf( -24266L ) ) ); } else { value = value.longValue(); expected = -24266L; @@ -985,9 +594,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[20].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[20].sv_id.constellation + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[20].sv_id.constellation + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -995,9 +602,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[20].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[20].sv_id.satId + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[20].sv_id.satId + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -1005,9 +610,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[21].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[21].residual + "' != '" + 22272 + "'", - value.equals(BigInteger.valueOf(22272L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[21].residual + "' != '" + 22272 + "'", value.equals(BigInteger.valueOf( 22272L ) ) ); } else { value = value.longValue(); expected = 22272L; @@ -1015,9 +618,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[21].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[21].sv_id.constellation + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[21].sv_id.constellation + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -1025,9 +626,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[21].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[21].sv_id.satId + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[21].sv_id.satId + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1035,9 +634,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[22].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[22].residual + "' != '" + 9303 + "'", - value.equals(BigInteger.valueOf(9303L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[22].residual + "' != '" + 9303 + "'", value.equals(BigInteger.valueOf( 9303L ) ) ); } else { value = value.longValue(); expected = 9303L; @@ -1045,9 +642,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[22].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[22].sv_id.constellation + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[22].sv_id.constellation + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -1055,9 +650,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[22].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[22].sv_id.satId + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[22].sv_id.satId + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1065,9 +658,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[23].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[23].residual + "' != '" + -23794 + "'", - value.equals(BigInteger.valueOf(-23794L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[23].residual + "' != '" + -23794 + "'", value.equals(BigInteger.valueOf( -23794L ) ) ); } else { value = value.longValue(); expected = -23794L; @@ -1075,9 +666,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[23].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[23].sv_id.constellation + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[23].sv_id.constellation + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -1085,9 +674,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[23].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[23].sv_id.satId + "' != '" + 184 + "'", - value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[23].sv_id.satId + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -1095,9 +682,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[24].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[24].residual + "' != '" + -26837 + "'", - value.equals(BigInteger.valueOf(-26837L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[24].residual + "' != '" + -26837 + "'", value.equals(BigInteger.valueOf( -26837L ) ) ); } else { value = value.longValue(); expected = -26837L; @@ -1105,9 +690,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[24].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[24].sv_id.constellation + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[24].sv_id.constellation + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -1115,9 +698,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[24].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[24].sv_id.satId + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[24].sv_id.satId + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -1125,9 +706,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[25].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[25].residual + "' != '" + 14631 + "'", - value.equals(BigInteger.valueOf(14631L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[25].residual + "' != '" + 14631 + "'", value.equals(BigInteger.valueOf( 14631L ) ) ); } else { value = value.longValue(); expected = 14631L; @@ -1135,9 +714,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[25].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[25].sv_id.constellation + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[25].sv_id.constellation + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -1145,9 +722,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[25].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[25].sv_id.satId + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[25].sv_id.satId + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -1155,9 +730,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[26].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[26].residual + "' != '" + -8144 + "'", - value.equals(BigInteger.valueOf(-8144L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[26].residual + "' != '" + -8144 + "'", value.equals(BigInteger.valueOf( -8144L ) ) ); } else { value = value.longValue(); expected = -8144L; @@ -1165,9 +738,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[26].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[26].sv_id.constellation + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[26].sv_id.constellation + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -1175,9 +746,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[26].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[26].sv_id.satId + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[26].sv_id.satId + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -1185,9 +754,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[27].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[27].residual + "' != '" + 23612 + "'", - value.equals(BigInteger.valueOf(23612L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[27].residual + "' != '" + 23612 + "'", value.equals(BigInteger.valueOf( 23612L ) ) ); } else { value = value.longValue(); expected = 23612L; @@ -1195,9 +762,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[27].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[27].sv_id.constellation + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[27].sv_id.constellation + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -1205,9 +770,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[27].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[27].sv_id.satId + "' != '" + 181 + "'", - value.equals(BigInteger.valueOf(181L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[27].sv_id.satId + "' != '" + 181 + "'", value.equals(BigInteger.valueOf( 181L ) ) ); } else { value = value.longValue(); expected = 181L; @@ -1215,9 +778,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[28].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[28].residual + "' != '" + 28013 + "'", - value.equals(BigInteger.valueOf(28013L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[28].residual + "' != '" + 28013 + "'", value.equals(BigInteger.valueOf( 28013L ) ) ); } else { value = value.longValue(); expected = 28013L; @@ -1225,9 +786,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[28].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[28].sv_id.constellation + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[28].sv_id.constellation + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -1235,9 +794,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[28].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[28].sv_id.satId + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[28].sv_id.satId + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -1245,9 +802,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[29].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[29].residual + "' != '" + 2166 + "'", - value.equals(BigInteger.valueOf(2166L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[29].residual + "' != '" + 2166 + "'", value.equals(BigInteger.valueOf( 2166L ) ) ); } else { value = value.longValue(); expected = 2166L; @@ -1255,9 +810,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[29].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[29].sv_id.constellation + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[29].sv_id.constellation + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1265,9 +818,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[29].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[29].sv_id.satId + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[29].sv_id.satId + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1275,9 +826,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[30].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[30].residual + "' != '" + -10186 + "'", - value.equals(BigInteger.valueOf(-10186L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[30].residual + "' != '" + -10186 + "'", value.equals(BigInteger.valueOf( -10186L ) ) ); } else { value = value.longValue(); expected = -10186L; @@ -1285,9 +834,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[30].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[30].sv_id.constellation + "' != '" + 159 + "'", - value.equals(BigInteger.valueOf(159L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[30].sv_id.constellation + "' != '" + 159 + "'", value.equals(BigInteger.valueOf( 159L ) ) ); } else { value = value.longValue(); expected = 159L; @@ -1295,9 +842,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[30].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[30].sv_id.satId + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[30].sv_id.satId + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -1305,9 +850,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[31].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[31].residual + "' != '" + 17432 + "'", - value.equals(BigInteger.valueOf(17432L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[31].residual + "' != '" + 17432 + "'", value.equals(BigInteger.valueOf( 17432L ) ) ); } else { value = value.longValue(); expected = 17432L; @@ -1315,9 +858,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[31].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[31].sv_id.constellation + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[31].sv_id.constellation + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -1325,9 +866,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[31].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[31].sv_id.satId + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[31].sv_id.satId + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -1335,9 +874,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[32].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[32].residual + "' != '" + -8666 + "'", - value.equals(BigInteger.valueOf(-8666L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[32].residual + "' != '" + -8666 + "'", value.equals(BigInteger.valueOf( -8666L ) ) ); } else { value = value.longValue(); expected = -8666L; @@ -1345,9 +882,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[32].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[32].sv_id.constellation + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[32].sv_id.constellation + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -1355,9 +890,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[32].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[32].sv_id.satId + "' != '" + 160 + "'", - value.equals(BigInteger.valueOf(160L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[32].sv_id.satId + "' != '" + 160 + "'", value.equals(BigInteger.valueOf( 160L ) ) ); } else { value = value.longValue(); expected = 160L; @@ -1365,9 +898,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[33].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[33].residual + "' != '" + 25436 + "'", - value.equals(BigInteger.valueOf(25436L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[33].residual + "' != '" + 25436 + "'", value.equals(BigInteger.valueOf( 25436L ) ) ); } else { value = value.longValue(); expected = 25436L; @@ -1375,9 +906,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[33].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[33].sv_id.constellation + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[33].sv_id.constellation + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -1385,9 +914,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[33].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[33].sv_id.satId + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[33].sv_id.satId + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -1395,9 +922,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[34].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[34].residual + "' != '" + -3864 + "'", - value.equals(BigInteger.valueOf(-3864L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[34].residual + "' != '" + -3864 + "'", value.equals(BigInteger.valueOf( -3864L ) ) ); } else { value = value.longValue(); expected = -3864L; @@ -1405,9 +930,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[34].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[34].sv_id.constellation + "' != '" + 159 + "'", - value.equals(BigInteger.valueOf(159L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[34].sv_id.constellation + "' != '" + 159 + "'", value.equals(BigInteger.valueOf( 159L ) ) ); } else { value = value.longValue(); expected = 159L; @@ -1415,9 +938,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[34].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[34].sv_id.satId + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[34].sv_id.satId + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -1425,9 +946,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[35].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[35].residual + "' != '" + 4093 + "'", - value.equals(BigInteger.valueOf(4093L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[35].residual + "' != '" + 4093 + "'", value.equals(BigInteger.valueOf( 4093L ) ) ); } else { value = value.longValue(); expected = 4093L; @@ -1435,9 +954,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[35].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[35].sv_id.constellation + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[35].sv_id.constellation + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -1445,9 +962,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[35].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[35].sv_id.satId + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[35].sv_id.satId + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1455,9 +970,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[36].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[36].residual + "' != '" + -18055 + "'", - value.equals(BigInteger.valueOf(-18055L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[36].residual + "' != '" + -18055 + "'", value.equals(BigInteger.valueOf( -18055L ) ) ); } else { value = value.longValue(); expected = -18055L; @@ -1465,9 +978,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[36].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[36].sv_id.constellation + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[36].sv_id.constellation + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1475,9 +986,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[36].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[36].sv_id.satId + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[36].sv_id.satId + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -1485,9 +994,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[37].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[37].residual + "' != '" + -27900 + "'", - value.equals(BigInteger.valueOf(-27900L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[37].residual + "' != '" + -27900 + "'", value.equals(BigInteger.valueOf( -27900L ) ) ); } else { value = value.longValue(); expected = -27900L; @@ -1495,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[37].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[37].sv_id.constellation + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[37].sv_id.constellation + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1505,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[37].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[37].sv_id.satId + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[37].sv_id.satId + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -1515,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[38].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[38].residual + "' != '" + 30687 + "'", - value.equals(BigInteger.valueOf(30687L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[38].residual + "' != '" + 30687 + "'", value.equals(BigInteger.valueOf( 30687L ) ) ); } else { value = value.longValue(); expected = 30687L; @@ -1525,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[38].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[38].sv_id.constellation + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[38].sv_id.constellation + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -1535,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[38].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[38].sv_id.satId + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[38].sv_id.satId + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -1545,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[39].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[39].residual + "' != '" + -13151 + "'", - value.equals(BigInteger.valueOf(-13151L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[39].residual + "' != '" + -13151 + "'", value.equals(BigInteger.valueOf( -13151L ) ) ); } else { value = value.longValue(); expected = -13151L; @@ -1555,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[39].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[39].sv_id.constellation + "' != '" + 242 + "'", - value.equals(BigInteger.valueOf(242L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[39].sv_id.constellation + "' != '" + 242 + "'", value.equals(BigInteger.valueOf( 242L ) ) ); } else { value = value.longValue(); expected = 242L; @@ -1565,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[39].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[39].sv_id.satId + "' != '" + 226 + "'", - value.equals(BigInteger.valueOf(226L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[39].sv_id.satId + "' != '" + 226 + "'", value.equals(BigInteger.valueOf( 226L ) ) ); } else { value = value.longValue(); expected = 226L; @@ -1575,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[40].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[40].residual + "' != '" + -22903 + "'", - value.equals(BigInteger.valueOf(-22903L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[40].residual + "' != '" + -22903 + "'", value.equals(BigInteger.valueOf( -22903L ) ) ); } else { value = value.longValue(); expected = -22903L; @@ -1585,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[40].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[40].sv_id.constellation + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[40].sv_id.constellation + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -1595,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[40].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[40].sv_id.satId + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[40].sv_id.satId + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -1605,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[41].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[41].residual + "' != '" + 4988 + "'", - value.equals(BigInteger.valueOf(4988L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[41].residual + "' != '" + 4988 + "'", value.equals(BigInteger.valueOf( 4988L ) ) ); } else { value = value.longValue(); expected = 4988L; @@ -1615,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[41].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[41].sv_id.constellation + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[41].sv_id.constellation + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -1625,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[41].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[41].sv_id.satId + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[41].sv_id.satId + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -1635,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[42].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[42].residual + "' != '" + 27408 + "'", - value.equals(BigInteger.valueOf(27408L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[42].residual + "' != '" + 27408 + "'", value.equals(BigInteger.valueOf( 27408L ) ) ); } else { value = value.longValue(); expected = 27408L; @@ -1645,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[42].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[42].sv_id.constellation + "' != '" + 188 + "'", - value.equals(BigInteger.valueOf(188L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[42].sv_id.constellation + "' != '" + 188 + "'", value.equals(BigInteger.valueOf( 188L ) ) ); } else { value = value.longValue(); expected = 188L; @@ -1655,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[42].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[42].sv_id.satId + "' != '" + 181 + "'", - value.equals(BigInteger.valueOf(181L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[42].sv_id.satId + "' != '" + 181 + "'", value.equals(BigInteger.valueOf( 181L ) ) ); } else { value = value.longValue(); expected = 181L; @@ -1665,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[43].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[43].residual + "' != '" + 319 + "'", - value.equals(BigInteger.valueOf(319L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[43].residual + "' != '" + 319 + "'", value.equals(BigInteger.valueOf( 319L ) ) ); } else { value = value.longValue(); expected = 319L; @@ -1675,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[43].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[43].sv_id.constellation + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[43].sv_id.constellation + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -1685,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[43].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[43].sv_id.satId + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[43].sv_id.satId + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -1695,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[44].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[44].residual + "' != '" + 15987 + "'", - value.equals(BigInteger.valueOf(15987L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[44].residual + "' != '" + 15987 + "'", value.equals(BigInteger.valueOf( 15987L ) ) ); } else { value = value.longValue(); expected = 15987L; @@ -1705,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[44].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[44].sv_id.constellation + "' != '" + 252 + "'", - value.equals(BigInteger.valueOf(252L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[44].sv_id.constellation + "' != '" + 252 + "'", value.equals(BigInteger.valueOf( 252L ) ) ); } else { value = value.longValue(); expected = 252L; @@ -1715,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[44].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[44].sv_id.satId + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[44].sv_id.satId + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -1725,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[45].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[45].residual + "' != '" + 22266 + "'", - value.equals(BigInteger.valueOf(22266L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[45].residual + "' != '" + 22266 + "'", value.equals(BigInteger.valueOf( 22266L ) ) ); } else { value = value.longValue(); expected = 22266L; @@ -1735,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[45].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[45].sv_id.constellation + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[45].sv_id.constellation + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -1745,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[45].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[45].sv_id.satId + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[45].sv_id.satId + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -1755,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[46].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[46].residual + "' != '" + -19919 + "'", - value.equals(BigInteger.valueOf(-19919L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[46].residual + "' != '" + -19919 + "'", value.equals(BigInteger.valueOf( -19919L ) ) ); } else { value = value.longValue(); expected = -19919L; @@ -1765,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[46].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[46].sv_id.constellation + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[46].sv_id.constellation + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -1775,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[46].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[46].sv_id.satId + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[46].sv_id.satId + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -1785,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[47].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[47].residual + "' != '" + 17350 + "'", - value.equals(BigInteger.valueOf(17350L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[47].residual + "' != '" + 17350 + "'", value.equals(BigInteger.valueOf( 17350L ) ) ); } else { value = value.longValue(); expected = 17350L; @@ -1795,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[47].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[47].sv_id.constellation + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[47].sv_id.constellation + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -1805,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[47].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[47].sv_id.satId + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[47].sv_id.satId + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -1815,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[48].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[48].residual + "' != '" + 14410 + "'", - value.equals(BigInteger.valueOf(14410L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[48].residual + "' != '" + 14410 + "'", value.equals(BigInteger.valueOf( 14410L ) ) ); } else { value = value.longValue(); expected = 14410L; @@ -1825,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[48].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[48].sv_id.constellation + "' != '" + 253 + "'", - value.equals(BigInteger.valueOf(253L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[48].sv_id.constellation + "' != '" + 253 + "'", value.equals(BigInteger.valueOf( 253L ) ) ); } else { value = value.longValue(); expected = 253L; @@ -1835,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[48].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[48].sv_id.satId + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[48].sv_id.satId + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -1845,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[49].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[49].residual + "' != '" + 23671 + "'", - value.equals(BigInteger.valueOf(23671L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[49].residual + "' != '" + 23671 + "'", value.equals(BigInteger.valueOf( 23671L ) ) ); } else { value = value.longValue(); expected = 23671L; @@ -1855,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[49].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[49].sv_id.constellation + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[49].sv_id.constellation + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -1865,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[49].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[49].sv_id.satId + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[49].sv_id.satId + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -1875,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[50].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[50].residual + "' != '" + -31905 + "'", - value.equals(BigInteger.valueOf(-31905L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[50].residual + "' != '" + -31905 + "'", value.equals(BigInteger.valueOf( -31905L ) ) ); } else { value = value.longValue(); expected = -31905L; @@ -1885,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[50].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[50].sv_id.constellation + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[50].sv_id.constellation + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -1895,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[50].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[50].sv_id.satId + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[50].sv_id.satId + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -1905,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[51].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[51].residual + "' != '" + 14305 + "'", - value.equals(BigInteger.valueOf(14305L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[51].residual + "' != '" + 14305 + "'", value.equals(BigInteger.valueOf( 14305L ) ) ); } else { value = value.longValue(); expected = 14305L; @@ -1915,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[51].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[51].sv_id.constellation + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[51].sv_id.constellation + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -1925,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[51].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[51].sv_id.satId + "' != '" + 89 + "'", - value.equals(BigInteger.valueOf(89L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[51].sv_id.satId + "' != '" + 89 + "'", value.equals(BigInteger.valueOf( 89L ) ) ); } else { value = value.longValue(); expected = 89L; @@ -1935,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[52].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[52].residual + "' != '" + -12968 + "'", - value.equals(BigInteger.valueOf(-12968L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[52].residual + "' != '" + -12968 + "'", value.equals(BigInteger.valueOf( -12968L ) ) ); } else { value = value.longValue(); expected = -12968L; @@ -1945,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[52].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[52].sv_id.constellation + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[52].sv_id.constellation + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -1955,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[52].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[52].sv_id.satId + "' != '" + 95 + "'", - value.equals(BigInteger.valueOf(95L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[52].sv_id.satId + "' != '" + 95 + "'", value.equals(BigInteger.valueOf( 95L ) ) ); } else { value = value.longValue(); expected = 95L; @@ -1965,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[53].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[53].residual + "' != '" + 21479 + "'", - value.equals(BigInteger.valueOf(21479L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[53].residual + "' != '" + 21479 + "'", value.equals(BigInteger.valueOf( 21479L ) ) ); } else { value = value.longValue(); expected = 21479L; @@ -1975,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[53].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[53].sv_id.constellation + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[53].sv_id.constellation + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1985,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[53].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[53].sv_id.satId + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[53].sv_id.satId + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -1995,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[54].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[54].residual + "' != '" + 28260 + "'", - value.equals(BigInteger.valueOf(28260L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[54].residual + "' != '" + 28260 + "'", value.equals(BigInteger.valueOf( 28260L ) ) ); } else { value = value.longValue(); expected = 28260L; @@ -2005,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[54].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[54].sv_id.constellation + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[54].sv_id.constellation + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -2015,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[54].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[54].sv_id.satId + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[54].sv_id.satId + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -2025,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[55].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[55].residual + "' != '" + -11112 + "'", - value.equals(BigInteger.valueOf(-11112L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[55].residual + "' != '" + -11112 + "'", value.equals(BigInteger.valueOf( -11112L ) ) ); } else { value = value.longValue(); expected = -11112L; @@ -2035,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[55].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[55].sv_id.constellation + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[55].sv_id.constellation + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -2045,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[55].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[55].sv_id.satId + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[55].sv_id.satId + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -2055,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[56].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[56].residual + "' != '" + -25304 + "'", - value.equals(BigInteger.valueOf(-25304L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[56].residual + "' != '" + -25304 + "'", value.equals(BigInteger.valueOf( -25304L ) ) ); } else { value = value.longValue(); expected = -25304L; @@ -2065,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[56].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[56].sv_id.constellation + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[56].sv_id.constellation + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -2075,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[56].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[56].sv_id.satId + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[56].sv_id.satId + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -2085,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[57].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[57].residual + "' != '" + -4024 + "'", - value.equals(BigInteger.valueOf(-4024L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[57].residual + "' != '" + -4024 + "'", value.equals(BigInteger.valueOf( -4024L ) ) ); } else { value = value.longValue(); expected = -4024L; @@ -2095,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[57].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[57].sv_id.constellation + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[57].sv_id.constellation + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -2105,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[57].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[57].sv_id.satId + "' != '" + 244 + "'", - value.equals(BigInteger.valueOf(244L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[57].sv_id.satId + "' != '" + 244 + "'", value.equals(BigInteger.valueOf( 244L ) ) ); } else { value = value.longValue(); expected = 244L; @@ -2115,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[58].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[58].residual + "' != '" + -15505 + "'", - value.equals(BigInteger.valueOf(-15505L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[58].residual + "' != '" + -15505 + "'", value.equals(BigInteger.valueOf( -15505L ) ) ); } else { value = value.longValue(); expected = -15505L; @@ -2125,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[58].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[58].sv_id.constellation + "' != '" + 189 + "'", - value.equals(BigInteger.valueOf(189L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[58].sv_id.constellation + "' != '" + 189 + "'", value.equals(BigInteger.valueOf( 189L ) ) ); } else { value = value.longValue(); expected = 189L; @@ -2135,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[58].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[58].sv_id.satId + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[58].sv_id.satId + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -2145,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.tropo_delay_correction.hydro; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.hydro + "' != '" + 16250 + "'", - value.equals(BigInteger.valueOf(16250L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.hydro + "' != '" + 16250 + "'", value.equals(BigInteger.valueOf( 16250L ) ) ); } else { value = value.longValue(); expected = 16250L; @@ -2155,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.tropo_delay_correction.wet; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.wet + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.wet + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionTest.java b/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionTest.java index 8ea7f9ec7..905bce40a 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrGriddedCorrectionTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrection.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrGriddedCorrection.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrGriddedCorrection; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrGriddedCorrectionTest { @@ -30,272 +34,15 @@ public class auto_check_sbp_ssr_MsgSsrGriddedCorrectionTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrGriddedCorrectionTest.test1"); - byte[] payload = - new byte[] { - (byte) 21, - (byte) 14, - (byte) 151, - (byte) 50, - (byte) 120, - (byte) 133, - (byte) 29, - (byte) 151, - (byte) 174, - (byte) 229, - (byte) 151, - (byte) 189, - (byte) 204, - (byte) 196, - (byte) 105, - (byte) 170, - (byte) 120, - (byte) 149, - (byte) 169, - (byte) 37, - (byte) 244, - (byte) 78, - (byte) 72, - (byte) 140, - (byte) 101, - (byte) 2, - (byte) 173, - (byte) 88, - (byte) 70, - (byte) 180, - (byte) 54, - (byte) 152, - (byte) 115, - (byte) 78, - (byte) 201, - (byte) 161, - (byte) 23, - (byte) 135, - (byte) 152, - (byte) 98, - (byte) 61, - (byte) 75, - (byte) 178, - (byte) 120, - (byte) 229, - (byte) 146, - (byte) 55, - (byte) 58, - (byte) 169, - (byte) 234, - (byte) 230, - (byte) 69, - (byte) 172, - (byte) 191, - (byte) 127, - (byte) 146, - (byte) 89, - (byte) 150, - (byte) 91, - (byte) 111, - (byte) 225, - (byte) 41, - (byte) 17, - (byte) 119, - (byte) 52, - (byte) 166, - (byte) 166, - (byte) 120, - (byte) 57, - (byte) 221, - (byte) 12, - (byte) 3, - (byte) 156, - (byte) 70, - (byte) 156, - (byte) 35, - (byte) 127, - (byte) 8, - (byte) 127, - (byte) 58, - (byte) 128, - (byte) 55, - (byte) 115, - (byte) 80, - (byte) 157, - (byte) 122, - (byte) 153, - (byte) 124, - (byte) 27, - (byte) 128, - (byte) 98, - (byte) 103, - (byte) 204, - (byte) 75, - (byte) 238, - (byte) 128, - (byte) 226, - (byte) 148, - (byte) 248, - (byte) 61, - (byte) 216, - (byte) 208, - (byte) 149, - (byte) 167, - (byte) 224, - (byte) 40, - (byte) 144, - (byte) 186, - (byte) 157, - (byte) 227, - (byte) 72, - (byte) 240, - (byte) 100, - (byte) 35, - (byte) 12, - (byte) 212, - (byte) 7, - (byte) 59, - (byte) 176, - (byte) 81, - (byte) 86, - (byte) 27, - (byte) 24, - (byte) 155, - (byte) 67, - (byte) 43, - (byte) 132, - (byte) 45, - (byte) 203, - (byte) 44, - (byte) 6, - (byte) 112, - (byte) 183, - (byte) 231, - (byte) 176, - (byte) 79, - (byte) 194, - (byte) 253, - (byte) 247, - (byte) 103, - (byte) 91, - (byte) 226, - (byte) 116, - (byte) 148, - (byte) 23, - (byte) 62, - (byte) 227, - (byte) 240, - (byte) 29, - (byte) 219, - (byte) 205, - (byte) 18, - (byte) 242, - (byte) 207, - (byte) 72, - (byte) 71, - (byte) 79, - (byte) 37, - (byte) 42, - (byte) 176, - (byte) 201, - (byte) 202, - (byte) 91, - (byte) 105, - (byte) 115, - (byte) 146, - (byte) 59, - (byte) 110, - (byte) 44, - (byte) 109, - (byte) 128, - (byte) 183, - (byte) 185, - (byte) 67, - (byte) 31, - (byte) 165, - (byte) 92, - (byte) 79, - (byte) 189, - (byte) 180, - (byte) 94, - (byte) 7, - (byte) 162, - (byte) 121, - (byte) 156, - (byte) 210, - (byte) 47, - (byte) 7, - (byte) 7, - (byte) 205, - (byte) 174, - (byte) 41, - (byte) 241, - (byte) 129, - (byte) 210, - (byte) 43, - (byte) 101, - (byte) 186, - (byte) 208, - (byte) 195, - (byte) 226, - (byte) 247, - (byte) 187, - (byte) 219, - (byte) 160, - (byte) 120, - (byte) 192, - (byte) 102, - (byte) 166, - (byte) 42, - (byte) 246, - (byte) 173, - (byte) 94, - (byte) 102, - (byte) 156, - (byte) 222, - (byte) 30, - (byte) 35, - (byte) 247, - (byte) 64, - (byte) 189, - (byte) 137, - (byte) 204, - (byte) 220, - (byte) 32, - (byte) 71, - (byte) 222, - (byte) 222, - (byte) 201, - (byte) 246, - (byte) 3, - (byte) 25, - (byte) 45, - (byte) 251, - (byte) 239, - (byte) 115, - (byte) 88, - (byte) 218, - (byte) 10, - (byte) 209, - (byte) 120, - (byte) 65, - (byte) 175, - (byte) 131, - (byte) 194, - (byte) 41, - (byte) 174, - (byte) 137, - (byte) 17, - (byte) 68, - (byte) 28, - (byte) 253, - (byte) 42, - }; - SBPMessage sbp = new SBPMessage(0xf9c4, 0x5fc, payload); - MsgSsrGriddedCorrection msg = new MsgSsrGriddedCorrection(sbp); + byte[] payload = new byte[] {(byte)21,(byte)14,(byte)151,(byte)50,(byte)120,(byte)133,(byte)29,(byte)151,(byte)174,(byte)229,(byte)151,(byte)189,(byte)204,(byte)196,(byte)105,(byte)170,(byte)120,(byte)149,(byte)169,(byte)37,(byte)244,(byte)78,(byte)72,(byte)140,(byte)101,(byte)2,(byte)173,(byte)88,(byte)70,(byte)180,(byte)54,(byte)152,(byte)115,(byte)78,(byte)201,(byte)161,(byte)23,(byte)135,(byte)152,(byte)98,(byte)61,(byte)75,(byte)178,(byte)120,(byte)229,(byte)146,(byte)55,(byte)58,(byte)169,(byte)234,(byte)230,(byte)69,(byte)172,(byte)191,(byte)127,(byte)146,(byte)89,(byte)150,(byte)91,(byte)111,(byte)225,(byte)41,(byte)17,(byte)119,(byte)52,(byte)166,(byte)166,(byte)120,(byte)57,(byte)221,(byte)12,(byte)3,(byte)156,(byte)70,(byte)156,(byte)35,(byte)127,(byte)8,(byte)127,(byte)58,(byte)128,(byte)55,(byte)115,(byte)80,(byte)157,(byte)122,(byte)153,(byte)124,(byte)27,(byte)128,(byte)98,(byte)103,(byte)204,(byte)75,(byte)238,(byte)128,(byte)226,(byte)148,(byte)248,(byte)61,(byte)216,(byte)208,(byte)149,(byte)167,(byte)224,(byte)40,(byte)144,(byte)186,(byte)157,(byte)227,(byte)72,(byte)240,(byte)100,(byte)35,(byte)12,(byte)212,(byte)7,(byte)59,(byte)176,(byte)81,(byte)86,(byte)27,(byte)24,(byte)155,(byte)67,(byte)43,(byte)132,(byte)45,(byte)203,(byte)44,(byte)6,(byte)112,(byte)183,(byte)231,(byte)176,(byte)79,(byte)194,(byte)253,(byte)247,(byte)103,(byte)91,(byte)226,(byte)116,(byte)148,(byte)23,(byte)62,(byte)227,(byte)240,(byte)29,(byte)219,(byte)205,(byte)18,(byte)242,(byte)207,(byte)72,(byte)71,(byte)79,(byte)37,(byte)42,(byte)176,(byte)201,(byte)202,(byte)91,(byte)105,(byte)115,(byte)146,(byte)59,(byte)110,(byte)44,(byte)109,(byte)128,(byte)183,(byte)185,(byte)67,(byte)31,(byte)165,(byte)92,(byte)79,(byte)189,(byte)180,(byte)94,(byte)7,(byte)162,(byte)121,(byte)156,(byte)210,(byte)47,(byte)7,(byte)7,(byte)205,(byte)174,(byte)41,(byte)241,(byte)129,(byte)210,(byte)43,(byte)101,(byte)186,(byte)208,(byte)195,(byte)226,(byte)247,(byte)187,(byte)219,(byte)160,(byte)120,(byte)192,(byte)102,(byte)166,(byte)42,(byte)246,(byte)173,(byte)94,(byte)102,(byte)156,(byte)222,(byte)30,(byte)35,(byte)247,(byte)64,(byte)189,(byte)137,(byte)204,(byte)220,(byte)32,(byte)71,(byte)222,(byte)222,(byte)201,(byte)246,(byte)3,(byte)25,(byte)45,(byte)251,(byte)239,(byte)115,(byte)88,(byte)218,(byte)10,(byte)209,(byte)120,(byte)65,(byte)175,(byte)131,(byte)194,(byte)41,(byte)174,(byte)137,(byte)17,(byte)68,(byte)28,(byte)253,(byte)42, }; + SBPMessage sbp = new SBPMessage( 0xf9c4, 0x5fc, payload ); + MsgSsrGriddedCorrection msg = new MsgSsrGriddedCorrection( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.header.iod_atmo; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.iod_atmo + "' != '" + 170 + "'", - value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.header.iod_atmo + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -303,9 +50,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 48535 + "'", - value.equals(BigInteger.valueOf(48535L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 48535 + "'", value.equals(BigInteger.valueOf( 48535L ) ) ); } else { value = value.longValue(); expected = 48535L; @@ -313,9 +58,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 50380 + "'", - value.equals(BigInteger.valueOf(50380L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 50380 + "'", value.equals(BigInteger.valueOf( 50380L ) ) ); } else { value = value.longValue(); expected = 50380L; @@ -323,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tile_id + "' != '" + 12951 + "'", - value.equals(BigInteger.valueOf(12951L))); + org.junit.Assert.assertTrue("'" + msg.header.tile_id + "' != '" + 12951 + "'", value.equals(BigInteger.valueOf( 12951L ) ) ); } else { value = value.longValue(); expected = 12951L; @@ -333,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tile_set_id + "' != '" + 3605 + "'", - value.equals(BigInteger.valueOf(3605L))); + org.junit.Assert.assertTrue("'" + msg.header.tile_set_id + "' != '" + 3605 + "'", value.equals(BigInteger.valueOf( 3605L ) ) ); } else { value = value.longValue(); expected = 3605L; @@ -343,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.tow + "' != '" + 2535294328L + "'", - value.equals(new BigInteger("2535294328"))); + org.junit.Assert.assertTrue("'" + msg.header.time.tow + "' != '" + 2535294328L + "'", value.equals( new BigInteger( "2535294328" ) ) ); } else { value = value.longValue(); expected = 2535294328L; @@ -353,9 +90,7 @@ public void test1() throws Throwable { } value = msg.header.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.wn + "' != '" + 58798 + "'", - value.equals(BigInteger.valueOf(58798L))); + org.junit.Assert.assertTrue("'" + msg.header.time.wn + "' != '" + 58798 + "'", value.equals(BigInteger.valueOf( 58798L ) ) ); } else { value = value.longValue(); expected = 58798L; @@ -363,9 +98,7 @@ public void test1() throws Throwable { } value = msg.header.tropo_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tropo_quality_indicator + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.header.tropo_quality_indicator + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -373,9 +106,7 @@ public void test1() throws Throwable { } value = msg.header.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.update_interval + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.header.update_interval + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -383,9 +114,7 @@ public void test1() throws Throwable { } value = msg.index; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.index + "' != '" + 43413 + "'", - value.equals(BigInteger.valueOf(43413L))); + org.junit.Assert.assertTrue("'" + msg.index + "' != '" + 43413 + "'", value.equals(BigInteger.valueOf( 43413L ) ) ); } else { value = value.longValue(); expected = 43413L; @@ -393,9 +122,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[0].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[0].residual + "' != '" + -21246 + "'", - value.equals(BigInteger.valueOf(-21246L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[0].residual + "' != '" + -21246 + "'", value.equals(BigInteger.valueOf( -21246L ) ) ); } else { value = value.longValue(); expected = -21246L; @@ -403,9 +130,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[0].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[0].stddev + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[0].stddev + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -413,9 +138,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[0].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[0].sv_id.constellation + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[0].sv_id.constellation + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -423,9 +146,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[0].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[0].sv_id.satId + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[0].sv_id.satId + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -433,9 +154,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[1].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[1].residual + "' != '" + -26570 + "'", - value.equals(BigInteger.valueOf(-26570L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[1].residual + "' != '" + -26570 + "'", value.equals(BigInteger.valueOf( -26570L ) ) ); } else { value = value.longValue(); expected = -26570L; @@ -443,9 +162,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[1].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[1].stddev + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[1].stddev + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -453,9 +170,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[1].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[1].sv_id.constellation + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[1].sv_id.constellation + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -463,9 +178,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[1].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[1].sv_id.satId + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[1].sv_id.satId + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -473,9 +186,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[2].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[2].residual + "' != '" + 6049 + "'", - value.equals(BigInteger.valueOf(6049L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[2].residual + "' != '" + 6049 + "'", value.equals(BigInteger.valueOf( 6049L ) ) ); } else { value = value.longValue(); expected = 6049L; @@ -483,9 +194,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[2].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[2].stddev + "' != '" + 135 + "'", - value.equals(BigInteger.valueOf(135L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[2].stddev + "' != '" + 135 + "'", value.equals(BigInteger.valueOf( 135L ) ) ); } else { value = value.longValue(); expected = 135L; @@ -493,9 +202,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[2].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[2].sv_id.constellation + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[2].sv_id.constellation + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -503,9 +210,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[2].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[2].sv_id.satId + "' != '" + 78 + "'", - value.equals(BigInteger.valueOf(78L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[2].sv_id.satId + "' != '" + 78 + "'", value.equals(BigInteger.valueOf( 78L ) ) ); } else { value = value.longValue(); expected = 78L; @@ -513,9 +218,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[3].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[3].residual + "' != '" + 19261 + "'", - value.equals(BigInteger.valueOf(19261L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[3].residual + "' != '" + 19261 + "'", value.equals(BigInteger.valueOf( 19261L ) ) ); } else { value = value.longValue(); expected = 19261L; @@ -523,9 +226,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[3].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[3].stddev + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[3].stddev + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -533,9 +234,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[3].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[3].sv_id.constellation + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[3].sv_id.constellation + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -543,9 +242,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[3].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[3].sv_id.satId + "' != '" + 152 + "'", - value.equals(BigInteger.valueOf(152L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[3].sv_id.satId + "' != '" + 152 + "'", value.equals(BigInteger.valueOf( 152L ) ) ); } else { value = value.longValue(); expected = 152L; @@ -553,9 +250,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[4].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[4].residual + "' != '" + 14226 + "'", - value.equals(BigInteger.valueOf(14226L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[4].residual + "' != '" + 14226 + "'", value.equals(BigInteger.valueOf( 14226L ) ) ); } else { value = value.longValue(); expected = 14226L; @@ -563,9 +258,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[4].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[4].stddev + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[4].stddev + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -573,9 +266,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[4].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[4].sv_id.constellation + "' != '" + 229 + "'", - value.equals(BigInteger.valueOf(229L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[4].sv_id.constellation + "' != '" + 229 + "'", value.equals(BigInteger.valueOf( 229L ) ) ); } else { value = value.longValue(); expected = 229L; @@ -583,9 +274,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[4].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[4].sv_id.satId + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[4].sv_id.satId + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -593,9 +282,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[5].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[5].residual + "' != '" + 17894 + "'", - value.equals(BigInteger.valueOf(17894L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[5].residual + "' != '" + 17894 + "'", value.equals(BigInteger.valueOf( 17894L ) ) ); } else { value = value.longValue(); expected = 17894L; @@ -603,9 +290,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[5].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[5].stddev + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[5].stddev + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -613,9 +298,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[5].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[5].sv_id.constellation + "' != '" + 234 + "'", - value.equals(BigInteger.valueOf(234L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[5].sv_id.constellation + "' != '" + 234 + "'", value.equals(BigInteger.valueOf( 234L ) ) ); } else { value = value.longValue(); expected = 234L; @@ -623,9 +306,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[5].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[5].sv_id.satId + "' != '" + 169 + "'", - value.equals(BigInteger.valueOf(169L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[5].sv_id.satId + "' != '" + 169 + "'", value.equals(BigInteger.valueOf( 169L ) ) ); } else { value = value.longValue(); expected = 169L; @@ -633,9 +314,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[6].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[6].residual + "' != '" + 22930 + "'", - value.equals(BigInteger.valueOf(22930L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[6].residual + "' != '" + 22930 + "'", value.equals(BigInteger.valueOf( 22930L ) ) ); } else { value = value.longValue(); expected = 22930L; @@ -643,9 +322,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[6].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[6].stddev + "' != '" + 150 + "'", - value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[6].stddev + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -653,9 +330,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[6].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[6].sv_id.constellation + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[6].sv_id.constellation + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -663,9 +338,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[6].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[6].sv_id.satId + "' != '" + 191 + "'", - value.equals(BigInteger.valueOf(191L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[6].sv_id.satId + "' != '" + 191 + "'", value.equals(BigInteger.valueOf( 191L ) ) ); } else { value = value.longValue(); expected = 191L; @@ -673,9 +346,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[7].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[7].residual + "' != '" + 10721 + "'", - value.equals(BigInteger.valueOf(10721L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[7].residual + "' != '" + 10721 + "'", value.equals(BigInteger.valueOf( 10721L ) ) ); } else { value = value.longValue(); expected = 10721L; @@ -683,9 +354,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[7].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[7].stddev + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[7].stddev + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -693,9 +362,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[7].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[7].sv_id.constellation + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[7].sv_id.constellation + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -703,9 +370,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[7].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[7].sv_id.satId + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[7].sv_id.satId + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -713,9 +378,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[8].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[8].residual + "' != '" + -22874 + "'", - value.equals(BigInteger.valueOf(-22874L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[8].residual + "' != '" + -22874 + "'", value.equals(BigInteger.valueOf( -22874L ) ) ); } else { value = value.longValue(); expected = -22874L; @@ -723,9 +386,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[8].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[8].stddev + "' != '" + 120 + "'", - value.equals(BigInteger.valueOf(120L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[8].stddev + "' != '" + 120 + "'", value.equals(BigInteger.valueOf( 120L ) ) ); } else { value = value.longValue(); expected = 120L; @@ -733,9 +394,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[8].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[8].sv_id.constellation + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[8].sv_id.constellation + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -743,9 +402,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[8].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[8].sv_id.satId + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[8].sv_id.satId + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -753,9 +410,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[9].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[9].residual + "' != '" + 780 + "'", - value.equals(BigInteger.valueOf(780L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[9].residual + "' != '" + 780 + "'", value.equals(BigInteger.valueOf( 780L ) ) ); } else { value = value.longValue(); expected = 780L; @@ -763,9 +418,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[9].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[9].stddev + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[9].stddev + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -773,9 +426,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[9].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[9].sv_id.constellation + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[9].sv_id.constellation + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -783,9 +434,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[9].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[9].sv_id.satId + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[9].sv_id.satId + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -793,9 +442,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[10].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[10].residual + "' != '" + 32547 + "'", - value.equals(BigInteger.valueOf(32547L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[10].residual + "' != '" + 32547 + "'", value.equals(BigInteger.valueOf( 32547L ) ) ); } else { value = value.longValue(); expected = 32547L; @@ -803,9 +450,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[10].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[10].stddev + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[10].stddev + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -813,9 +458,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[10].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[10].sv_id.constellation + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[10].sv_id.constellation + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -823,9 +466,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[10].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[10].sv_id.satId + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[10].sv_id.satId + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -833,9 +474,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[11].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[11].residual + "' != '" + 14208 + "'", - value.equals(BigInteger.valueOf(14208L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[11].residual + "' != '" + 14208 + "'", value.equals(BigInteger.valueOf( 14208L ) ) ); } else { value = value.longValue(); expected = 14208L; @@ -843,9 +482,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[11].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[11].stddev + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[11].stddev + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -853,9 +490,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[11].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[11].sv_id.constellation + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[11].sv_id.constellation + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -863,9 +498,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[11].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[11].sv_id.satId + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[11].sv_id.satId + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -873,9 +506,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[12].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[12].residual + "' != '" + -26246 + "'", - value.equals(BigInteger.valueOf(-26246L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[12].residual + "' != '" + -26246 + "'", value.equals(BigInteger.valueOf( -26246L ) ) ); } else { value = value.longValue(); expected = -26246L; @@ -883,9 +514,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[12].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[12].stddev + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[12].stddev + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -893,9 +522,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[12].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[12].sv_id.constellation + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[12].sv_id.constellation + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -903,9 +530,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[12].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[12].sv_id.satId + "' != '" + 80 + "'", - value.equals(BigInteger.valueOf(80L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[12].sv_id.satId + "' != '" + 80 + "'", value.equals(BigInteger.valueOf( 80L ) ) ); } else { value = value.longValue(); expected = 80L; @@ -913,9 +538,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[13].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[13].residual + "' != '" + 26466 + "'", - value.equals(BigInteger.valueOf(26466L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[13].residual + "' != '" + 26466 + "'", value.equals(BigInteger.valueOf( 26466L ) ) ); } else { value = value.longValue(); expected = 26466L; @@ -923,9 +546,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[13].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[13].stddev + "' != '" + 204 + "'", - value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[13].stddev + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -933,9 +554,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[13].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[13].sv_id.constellation + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[13].sv_id.constellation + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -943,9 +562,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[13].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[13].sv_id.satId + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[13].sv_id.satId + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -953,9 +570,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[14].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[14].residual + "' != '" + -7552 + "'", - value.equals(BigInteger.valueOf(-7552L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[14].residual + "' != '" + -7552 + "'", value.equals(BigInteger.valueOf( -7552L ) ) ); } else { value = value.longValue(); expected = -7552L; @@ -963,9 +578,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[14].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[14].stddev + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[14].stddev + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -973,9 +586,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[14].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[14].sv_id.constellation + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[14].sv_id.constellation + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -983,9 +594,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[14].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[14].sv_id.satId + "' != '" + 75 + "'", - value.equals(BigInteger.valueOf(75L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[14].sv_id.satId + "' != '" + 75 + "'", value.equals(BigInteger.valueOf( 75L ) ) ); } else { value = value.longValue(); expected = 75L; @@ -993,9 +602,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[15].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[15].residual + "' != '" + -12072 + "'", - value.equals(BigInteger.valueOf(-12072L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[15].residual + "' != '" + -12072 + "'", value.equals(BigInteger.valueOf( -12072L ) ) ); } else { value = value.longValue(); expected = -12072L; @@ -1003,9 +610,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[15].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[15].stddev + "' != '" + 149 + "'", - value.equals(BigInteger.valueOf(149L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[15].stddev + "' != '" + 149 + "'", value.equals(BigInteger.valueOf( 149L ) ) ); } else { value = value.longValue(); expected = 149L; @@ -1013,9 +618,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[15].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[15].sv_id.constellation + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[15].sv_id.constellation + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -1023,9 +626,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[15].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[15].sv_id.satId + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[15].sv_id.satId + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -1033,9 +634,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[16].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[16].residual + "' != '" + -28632 + "'", - value.equals(BigInteger.valueOf(-28632L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[16].residual + "' != '" + -28632 + "'", value.equals(BigInteger.valueOf( -28632L ) ) ); } else { value = value.longValue(); expected = -28632L; @@ -1043,9 +642,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[16].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[16].stddev + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[16].stddev + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -1053,9 +650,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[16].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[16].sv_id.constellation + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[16].sv_id.constellation + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -1063,9 +658,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[16].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[16].sv_id.satId + "' != '" + 167 + "'", - value.equals(BigInteger.valueOf(167L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[16].sv_id.satId + "' != '" + 167 + "'", value.equals(BigInteger.valueOf( 167L ) ) ); } else { value = value.longValue(); expected = 167L; @@ -1073,9 +666,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[17].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[17].residual + "' != '" + -4024 + "'", - value.equals(BigInteger.valueOf(-4024L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[17].residual + "' != '" + -4024 + "'", value.equals(BigInteger.valueOf( -4024L ) ) ); } else { value = value.longValue(); expected = -4024L; @@ -1083,9 +674,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[17].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[17].stddev + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[17].stddev + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -1093,9 +682,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[17].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[17].sv_id.constellation + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[17].sv_id.constellation + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1103,9 +690,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[17].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[17].sv_id.satId + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[17].sv_id.satId + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -1113,9 +698,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[18].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[18].residual + "' != '" + 2004 + "'", - value.equals(BigInteger.valueOf(2004L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[18].residual + "' != '" + 2004 + "'", value.equals(BigInteger.valueOf( 2004L ) ) ); } else { value = value.longValue(); expected = 2004L; @@ -1123,9 +706,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[18].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[18].stddev + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[18].stddev + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -1133,9 +714,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[18].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[18].sv_id.constellation + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[18].sv_id.constellation + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1143,9 +722,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[18].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[18].sv_id.satId + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[18].sv_id.satId + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -1153,9 +730,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[19].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[19].residual + "' != '" + 6998 + "'", - value.equals(BigInteger.valueOf(6998L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[19].residual + "' != '" + 6998 + "'", value.equals(BigInteger.valueOf( 6998L ) ) ); } else { value = value.longValue(); expected = 6998L; @@ -1163,9 +738,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[19].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[19].stddev + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[19].stddev + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -1173,9 +746,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[19].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[19].sv_id.constellation + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[19].sv_id.constellation + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -1183,9 +754,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[19].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[19].sv_id.satId + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[19].sv_id.satId + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -1193,9 +762,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[20].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[20].residual + "' != '" + -31701 + "'", - value.equals(BigInteger.valueOf(-31701L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[20].residual + "' != '" + -31701 + "'", value.equals(BigInteger.valueOf( -31701L ) ) ); } else { value = value.longValue(); expected = -31701L; @@ -1203,9 +770,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[20].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[20].stddev + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[20].stddev + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -1213,9 +778,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[20].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[20].sv_id.constellation + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[20].sv_id.constellation + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -1223,9 +786,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[20].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[20].sv_id.satId + "' != '" + 155 + "'", - value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[20].sv_id.satId + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -1233,9 +794,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[21].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[21].residual + "' != '" + 28678 + "'", - value.equals(BigInteger.valueOf(28678L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[21].residual + "' != '" + 28678 + "'", value.equals(BigInteger.valueOf( 28678L ) ) ); } else { value = value.longValue(); expected = 28678L; @@ -1243,9 +802,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[21].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[21].stddev + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[21].stddev + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -1253,9 +810,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[21].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[21].sv_id.constellation + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[21].sv_id.constellation + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -1263,9 +818,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[21].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[21].sv_id.satId + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[21].sv_id.satId + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -1273,9 +826,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[22].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[22].residual + "' != '" + -15793 + "'", - value.equals(BigInteger.valueOf(-15793L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[22].residual + "' != '" + -15793 + "'", value.equals(BigInteger.valueOf( -15793L ) ) ); } else { value = value.longValue(); expected = -15793L; @@ -1283,9 +834,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[22].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[22].stddev + "' != '" + 253 + "'", - value.equals(BigInteger.valueOf(253L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[22].stddev + "' != '" + 253 + "'", value.equals(BigInteger.valueOf( 253L ) ) ); } else { value = value.longValue(); expected = 253L; @@ -1293,9 +842,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[22].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[22].sv_id.constellation + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[22].sv_id.constellation + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -1303,9 +850,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[22].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[22].sv_id.satId + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[22].sv_id.satId + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -1313,9 +858,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[23].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[23].residual + "' != '" + -7589 + "'", - value.equals(BigInteger.valueOf(-7589L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[23].residual + "' != '" + -7589 + "'", value.equals(BigInteger.valueOf( -7589L ) ) ); } else { value = value.longValue(); expected = -7589L; @@ -1323,9 +866,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[23].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[23].stddev + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[23].stddev + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1333,9 +874,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[23].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[23].sv_id.constellation + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[23].sv_id.constellation + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -1343,9 +882,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[23].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[23].sv_id.satId + "' != '" + 247 + "'", - value.equals(BigInteger.valueOf(247L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[23].sv_id.satId + "' != '" + 247 + "'", value.equals(BigInteger.valueOf( 247L ) ) ); } else { value = value.longValue(); expected = 247L; @@ -1353,9 +890,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[24].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[24].residual + "' != '" + -7362 + "'", - value.equals(BigInteger.valueOf(-7362L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[24].residual + "' != '" + -7362 + "'", value.equals(BigInteger.valueOf( -7362L ) ) ); } else { value = value.longValue(); expected = -7362L; @@ -1363,9 +898,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[24].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[24].stddev + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[24].stddev + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -1373,9 +906,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[24].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[24].sv_id.constellation + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[24].sv_id.constellation + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1383,9 +914,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[24].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[24].sv_id.satId + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[24].sv_id.satId + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -1393,9 +922,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[25].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[25].residual + "' != '" + 4813 + "'", - value.equals(BigInteger.valueOf(4813L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[25].residual + "' != '" + 4813 + "'", value.equals(BigInteger.valueOf( 4813L ) ) ); } else { value = value.longValue(); expected = 4813L; @@ -1403,9 +930,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[25].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[25].stddev + "' != '" + 242 + "'", - value.equals(BigInteger.valueOf(242L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[25].stddev + "' != '" + 242 + "'", value.equals(BigInteger.valueOf( 242L ) ) ); } else { value = value.longValue(); expected = 242L; @@ -1413,9 +938,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[25].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[25].sv_id.constellation + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[25].sv_id.constellation + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -1423,9 +946,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[25].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[25].sv_id.satId + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[25].sv_id.satId + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -1433,9 +954,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[26].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[26].residual + "' != '" + 20295 + "'", - value.equals(BigInteger.valueOf(20295L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[26].residual + "' != '" + 20295 + "'", value.equals(BigInteger.valueOf( 20295L ) ) ); } else { value = value.longValue(); expected = 20295L; @@ -1443,9 +962,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[26].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[26].stddev + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[26].stddev + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -1453,9 +970,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[26].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[26].sv_id.constellation + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[26].sv_id.constellation + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -1463,9 +978,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[26].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[26].sv_id.satId + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[26].sv_id.satId + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -1473,9 +986,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[27].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[27].residual + "' != '" + -13623 + "'", - value.equals(BigInteger.valueOf(-13623L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[27].residual + "' != '" + -13623 + "'", value.equals(BigInteger.valueOf( -13623L ) ) ); } else { value = value.longValue(); expected = -13623L; @@ -1483,9 +994,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[27].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[27].stddev + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[27].stddev + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -1493,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[27].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[27].sv_id.constellation + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[27].sv_id.constellation + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -1503,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[27].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[27].sv_id.satId + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[27].sv_id.satId + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -1513,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[28].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[28].residual + "' != '" + 15250 + "'", - value.equals(BigInteger.valueOf(15250L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[28].residual + "' != '" + 15250 + "'", value.equals(BigInteger.valueOf( 15250L ) ) ); } else { value = value.longValue(); expected = 15250L; @@ -1523,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[28].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[28].stddev + "' != '" + 110 + "'", - value.equals(BigInteger.valueOf(110L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[28].stddev + "' != '" + 110 + "'", value.equals(BigInteger.valueOf( 110L ) ) ); } else { value = value.longValue(); expected = 110L; @@ -1533,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[28].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[28].sv_id.constellation + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[28].sv_id.constellation + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1543,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[28].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[28].sv_id.satId + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[28].sv_id.satId + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -1553,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[29].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[29].residual + "' != '" + -18560 + "'", - value.equals(BigInteger.valueOf(-18560L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[29].residual + "' != '" + -18560 + "'", value.equals(BigInteger.valueOf( -18560L ) ) ); } else { value = value.longValue(); expected = -18560L; @@ -1563,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[29].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[29].stddev + "' != '" + 185 + "'", - value.equals(BigInteger.valueOf(185L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[29].stddev + "' != '" + 185 + "'", value.equals(BigInteger.valueOf( 185L ) ) ); } else { value = value.longValue(); expected = 185L; @@ -1573,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[29].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[29].sv_id.constellation + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[29].sv_id.constellation + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -1583,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[29].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[29].sv_id.satId + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[29].sv_id.satId + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -1593,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[30].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[30].residual + "' != '" + 23717 + "'", - value.equals(BigInteger.valueOf(23717L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[30].residual + "' != '" + 23717 + "'", value.equals(BigInteger.valueOf( 23717L ) ) ); } else { value = value.longValue(); expected = 23717L; @@ -1603,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[30].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[30].stddev + "' != '" + 79 + "'", - value.equals(BigInteger.valueOf(79L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[30].stddev + "' != '" + 79 + "'", value.equals(BigInteger.valueOf( 79L ) ) ); } else { value = value.longValue(); expected = 79L; @@ -1613,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[30].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[30].sv_id.constellation + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[30].sv_id.constellation + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -1623,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[30].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[30].sv_id.satId + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[30].sv_id.satId + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -1633,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[31].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[31].residual + "' != '" + 1886 + "'", - value.equals(BigInteger.valueOf(1886L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[31].residual + "' != '" + 1886 + "'", value.equals(BigInteger.valueOf( 1886L ) ) ); } else { value = value.longValue(); expected = 1886L; @@ -1643,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[31].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[31].stddev + "' != '" + 162 + "'", - value.equals(BigInteger.valueOf(162L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[31].stddev + "' != '" + 162 + "'", value.equals(BigInteger.valueOf( 162L ) ) ); } else { value = value.longValue(); expected = 162L; @@ -1653,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[31].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[31].sv_id.constellation + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[31].sv_id.constellation + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -1663,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[31].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[31].sv_id.satId + "' != '" + 189 + "'", - value.equals(BigInteger.valueOf(189L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[31].sv_id.satId + "' != '" + 189 + "'", value.equals(BigInteger.valueOf( 189L ) ) ); } else { value = value.longValue(); expected = 189L; @@ -1673,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[32].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[32].residual + "' != '" + 12242 + "'", - value.equals(BigInteger.valueOf(12242L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[32].residual + "' != '" + 12242 + "'", value.equals(BigInteger.valueOf( 12242L ) ) ); } else { value = value.longValue(); expected = 12242L; @@ -1683,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[32].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[32].stddev + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[32].stddev + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -1693,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[32].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[32].sv_id.constellation + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[32].sv_id.constellation + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -1703,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[32].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[32].sv_id.satId + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[32].sv_id.satId + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -1713,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[33].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[33].residual + "' != '" + 10670 + "'", - value.equals(BigInteger.valueOf(10670L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[33].residual + "' != '" + 10670 + "'", value.equals(BigInteger.valueOf( 10670L ) ) ); } else { value = value.longValue(); expected = 10670L; @@ -1723,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[33].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[33].stddev + "' != '" + 241 + "'", - value.equals(BigInteger.valueOf(241L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[33].stddev + "' != '" + 241 + "'", value.equals(BigInteger.valueOf( 241L ) ) ); } else { value = value.longValue(); expected = 241L; @@ -1733,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[33].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[33].sv_id.constellation + "' != '" + 205 + "'", - value.equals(BigInteger.valueOf(205L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[33].sv_id.constellation + "' != '" + 205 + "'", value.equals(BigInteger.valueOf( 205L ) ) ); } else { value = value.longValue(); expected = 205L; @@ -1743,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[33].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[33].sv_id.satId + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[33].sv_id.satId + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -1753,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[34].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[34].residual + "' != '" + 25899 + "'", - value.equals(BigInteger.valueOf(25899L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[34].residual + "' != '" + 25899 + "'", value.equals(BigInteger.valueOf( 25899L ) ) ); } else { value = value.longValue(); expected = 25899L; @@ -1763,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[34].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[34].stddev + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[34].stddev + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -1773,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[34].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[34].sv_id.constellation + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[34].sv_id.constellation + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -1783,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[34].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[34].sv_id.satId + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[34].sv_id.satId + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -1793,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[35].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[35].residual + "' != '" + -2078 + "'", - value.equals(BigInteger.valueOf(-2078L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[35].residual + "' != '" + -2078 + "'", value.equals(BigInteger.valueOf( -2078L ) ) ); } else { value = value.longValue(); expected = -2078L; @@ -1803,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[35].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[35].stddev + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[35].stddev + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -1813,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[35].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[35].sv_id.constellation + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[35].sv_id.constellation + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -1823,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[35].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[35].sv_id.satId + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[35].sv_id.satId + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -1833,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[36].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[36].residual + "' != '" + -16264 + "'", - value.equals(BigInteger.valueOf(-16264L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[36].residual + "' != '" + -16264 + "'", value.equals(BigInteger.valueOf( -16264L ) ) ); } else { value = value.longValue(); expected = -16264L; @@ -1843,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[36].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[36].stddev + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[36].stddev + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -1853,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[36].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[36].sv_id.constellation + "' != '" + 160 + "'", - value.equals(BigInteger.valueOf(160L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[36].sv_id.constellation + "' != '" + 160 + "'", value.equals(BigInteger.valueOf( 160L ) ) ); } else { value = value.longValue(); expected = 160L; @@ -1863,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[36].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[36].sv_id.satId + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[36].sv_id.satId + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -1873,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[37].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[37].residual + "' != '" + -21002 + "'", - value.equals(BigInteger.valueOf(-21002L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[37].residual + "' != '" + -21002 + "'", value.equals(BigInteger.valueOf( -21002L ) ) ); } else { value = value.longValue(); expected = -21002L; @@ -1883,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[37].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[37].stddev + "' != '" + 94 + "'", - value.equals(BigInteger.valueOf(94L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[37].stddev + "' != '" + 94 + "'", value.equals(BigInteger.valueOf( 94L ) ) ); } else { value = value.longValue(); expected = 94L; @@ -1893,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[37].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[37].sv_id.constellation + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[37].sv_id.constellation + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -1903,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[37].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[37].sv_id.satId + "' != '" + 166 + "'", - value.equals(BigInteger.valueOf(166L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[37].sv_id.satId + "' != '" + 166 + "'", value.equals(BigInteger.valueOf( 166L ) ) ); } else { value = value.longValue(); expected = 166L; @@ -1913,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[38].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[38].residual + "' != '" + 7902 + "'", - value.equals(BigInteger.valueOf(7902L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[38].residual + "' != '" + 7902 + "'", value.equals(BigInteger.valueOf( 7902L ) ) ); } else { value = value.longValue(); expected = 7902L; @@ -1923,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[38].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[38].stddev + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[38].stddev + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -1933,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[38].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[38].sv_id.constellation + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[38].sv_id.constellation + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -1943,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[38].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[38].sv_id.satId + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[38].sv_id.satId + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -1953,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[39].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[39].residual + "' != '" + -30275 + "'", - value.equals(BigInteger.valueOf(-30275L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[39].residual + "' != '" + -30275 + "'", value.equals(BigInteger.valueOf( -30275L ) ) ); } else { value = value.longValue(); expected = -30275L; @@ -1963,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[39].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[39].stddev + "' != '" + 204 + "'", - value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[39].stddev + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -1973,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[39].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[39].sv_id.constellation + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[39].sv_id.constellation + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -1983,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[39].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[39].sv_id.satId + "' != '" + 247 + "'", - value.equals(BigInteger.valueOf(247L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[39].sv_id.satId + "' != '" + 247 + "'", value.equals(BigInteger.valueOf( 247L ) ) ); } else { value = value.longValue(); expected = 247L; @@ -1993,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[40].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[40].residual + "' != '" + -8633 + "'", - value.equals(BigInteger.valueOf(-8633L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[40].residual + "' != '" + -8633 + "'", value.equals(BigInteger.valueOf( -8633L ) ) ); } else { value = value.longValue(); expected = -8633L; @@ -2003,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[40].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[40].stddev + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[40].stddev + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -2013,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[40].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[40].sv_id.constellation + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[40].sv_id.constellation + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -2023,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[40].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[40].sv_id.satId + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[40].sv_id.satId + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -2033,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[41].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[41].residual + "' != '" + 6403 + "'", - value.equals(BigInteger.valueOf(6403L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[41].residual + "' != '" + 6403 + "'", value.equals(BigInteger.valueOf( 6403L ) ) ); } else { value = value.longValue(); expected = 6403L; @@ -2043,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[41].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[41].stddev + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[41].stddev + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -2053,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[41].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[41].sv_id.constellation + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[41].sv_id.constellation + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -2063,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[41].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[41].sv_id.satId + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[41].sv_id.satId + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -2073,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[42].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[42].residual + "' != '" + 22643 + "'", - value.equals(BigInteger.valueOf(22643L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[42].residual + "' != '" + 22643 + "'", value.equals(BigInteger.valueOf( 22643L ) ) ); } else { value = value.longValue(); expected = 22643L; @@ -2083,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[42].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[42].stddev + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[42].stddev + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -2093,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[42].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[42].sv_id.constellation + "' != '" + 239 + "'", - value.equals(BigInteger.valueOf(239L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[42].sv_id.constellation + "' != '" + 239 + "'", value.equals(BigInteger.valueOf( 239L ) ) ); } else { value = value.longValue(); expected = 239L; @@ -2103,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[42].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[42].sv_id.satId + "' != '" + 251 + "'", - value.equals(BigInteger.valueOf(251L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[42].sv_id.satId + "' != '" + 251 + "'", value.equals(BigInteger.valueOf( 251L ) ) ); } else { value = value.longValue(); expected = 251L; @@ -2113,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[43].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[43].residual + "' != '" + 16760 + "'", - value.equals(BigInteger.valueOf(16760L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[43].residual + "' != '" + 16760 + "'", value.equals(BigInteger.valueOf( 16760L ) ) ); } else { value = value.longValue(); expected = 16760L; @@ -2123,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[43].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[43].stddev + "' != '" + 175 + "'", - value.equals(BigInteger.valueOf(175L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[43].stddev + "' != '" + 175 + "'", value.equals(BigInteger.valueOf( 175L ) ) ); } else { value = value.longValue(); expected = 175L; @@ -2133,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[43].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[43].sv_id.constellation + "' != '" + 209 + "'", - value.equals(BigInteger.valueOf(209L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[43].sv_id.constellation + "' != '" + 209 + "'", value.equals(BigInteger.valueOf( 209L ) ) ); } else { value = value.longValue(); expected = 209L; @@ -2143,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[43].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[43].sv_id.satId + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[43].sv_id.satId + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -2153,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[44].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[44].residual + "' != '" + -20951 + "'", - value.equals(BigInteger.valueOf(-20951L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[44].residual + "' != '" + -20951 + "'", value.equals(BigInteger.valueOf( -20951L ) ) ); } else { value = value.longValue(); expected = -20951L; @@ -2163,9 +1538,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[44].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[44].stddev + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[44].stddev + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -2173,9 +1546,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[44].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[44].sv_id.constellation + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[44].sv_id.constellation + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -2183,9 +1554,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[44].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[44].sv_id.satId + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[44].sv_id.satId + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -2193,9 +1562,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[45].residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[45].residual + "' != '" + -740 + "'", - value.equals(BigInteger.valueOf(-740L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[45].residual + "' != '" + -740 + "'", value.equals(BigInteger.valueOf( -740L ) ) ); } else { value = value.longValue(); expected = -740L; @@ -2203,9 +1570,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[45].stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[45].stddev + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[45].stddev + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -2213,9 +1578,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[45].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[45].sv_id.constellation + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[45].sv_id.constellation + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -2223,9 +1586,7 @@ public void test1() throws Throwable { } value = msg.stec_residuals[45].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_residuals[45].sv_id.satId + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.stec_residuals[45].sv_id.satId + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -2233,9 +1594,7 @@ public void test1() throws Throwable { } value = msg.tropo_delay_correction.hydro; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.hydro + "' != '" + -3035 + "'", - value.equals(BigInteger.valueOf(-3035L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.hydro + "' != '" + -3035 + "'", value.equals(BigInteger.valueOf( -3035L ) ) ); } else { value = value.longValue(); expected = -3035L; @@ -2243,9 +1602,7 @@ public void test1() throws Throwable { } value = msg.tropo_delay_correction.stddev; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.stddev + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.stddev + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -2253,9 +1610,7 @@ public void test1() throws Throwable { } value = msg.tropo_delay_correction.wet; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tropo_delay_correction.wet + "' != '" + 78 + "'", - value.equals(BigInteger.valueOf(78L))); + org.junit.Assert.assertTrue("'" + msg.tropo_delay_correction.wet + "' != '" + 78 + "'", value.equals(BigInteger.valueOf( 78L ) ) ); } else { value = value.longValue(); expected = 78L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest.java b/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest.java index f38138c18..b08685869 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBoundsDegradation.yaml by generate.py. Do -// not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBoundsDegradation.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrOrbitClockBoundsDegradation; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest { @@ -29,48 +33,16 @@ public class auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest.test1"); - byte[] payload = - new byte[] { - (byte) 180, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 3, - (byte) 0, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 48, - (byte) 15, - (byte) 1, - (byte) 10, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 200, - (byte) 199, - (byte) 198, - (byte) 197, - (byte) 196, - (byte) 195, - (byte) 194, - (byte) 193, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x05DF, payload); - MsgSsrOrbitClockBoundsDegradation msg = new MsgSsrOrbitClockBoundsDegradation(sbp); + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrOrbitClockBoundsDegradationTest.test1"); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)1,(byte)2,(byte)3,(byte)48,(byte)15,(byte)1,(byte)10,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)200,(byte)199,(byte)198,(byte)197,(byte)196,(byte)195,(byte)194,(byte)193, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x05DF, payload ); + MsgSsrOrbitClockBoundsDegradation msg = new MsgSsrOrbitClockBoundsDegradation( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.const_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.const_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.const_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -78,9 +50,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -88,9 +58,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -98,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.sol_id + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.header.sol_id + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -108,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.header.time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -118,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -128,9 +90,7 @@ public void test1() throws Throwable { } value = msg.header.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.update_interval + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.update_interval + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -138,13 +98,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds_degradation.clock_bound_mu_dot; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" - + msg.orbit_clock_bounds_degradation.clock_bound_mu_dot - + "' != '" - + 194 - + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds_degradation.clock_bound_mu_dot + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -152,13 +106,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds_degradation.clock_bound_sig_dot; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" - + msg.orbit_clock_bounds_degradation.clock_bound_sig_dot - + "' != '" - + 193 - + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds_degradation.clock_bound_sig_dot + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -166,13 +114,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds_degradation.orb_along_bound_mu_dot; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" - + msg.orbit_clock_bounds_degradation.orb_along_bound_mu_dot - + "' != '" - + 199 - + "'", - value.equals(BigInteger.valueOf(199L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds_degradation.orb_along_bound_mu_dot + "' != '" + 199 + "'", value.equals(BigInteger.valueOf( 199L ) ) ); } else { value = value.longValue(); expected = 199L; @@ -180,13 +122,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds_degradation.orb_along_bound_sig_dot; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" - + msg.orbit_clock_bounds_degradation.orb_along_bound_sig_dot - + "' != '" - + 196 - + "'", - value.equals(BigInteger.valueOf(196L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds_degradation.orb_along_bound_sig_dot + "' != '" + 196 + "'", value.equals(BigInteger.valueOf( 196L ) ) ); } else { value = value.longValue(); expected = 196L; @@ -194,13 +130,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds_degradation.orb_cross_bound_mu_dot; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" - + msg.orbit_clock_bounds_degradation.orb_cross_bound_mu_dot - + "' != '" - + 198 - + "'", - value.equals(BigInteger.valueOf(198L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds_degradation.orb_cross_bound_mu_dot + "' != '" + 198 + "'", value.equals(BigInteger.valueOf( 198L ) ) ); } else { value = value.longValue(); expected = 198L; @@ -208,13 +138,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds_degradation.orb_cross_bound_sig_dot; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" - + msg.orbit_clock_bounds_degradation.orb_cross_bound_sig_dot - + "' != '" - + 195 - + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds_degradation.orb_cross_bound_sig_dot + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -222,13 +146,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds_degradation.orb_radial_bound_mu_dot; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" - + msg.orbit_clock_bounds_degradation.orb_radial_bound_mu_dot - + "' != '" - + 200 - + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds_degradation.orb_radial_bound_mu_dot + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -236,13 +154,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds_degradation.orb_radial_bound_sig_dot; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" - + msg.orbit_clock_bounds_degradation.orb_radial_bound_sig_dot - + "' != '" - + 197 - + "'", - value.equals(BigInteger.valueOf(197L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds_degradation.orb_radial_bound_sig_dot + "' != '" + 197 + "'", value.equals(BigInteger.valueOf( 197L ) ) ); } else { value = value.longValue(); expected = 197L; @@ -250,9 +162,7 @@ public void test1() throws Throwable { } value = msg.sat_bitmask; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sat_bitmask + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.sat_bitmask + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -260,8 +170,7 @@ public void test1() throws Throwable { } value = msg.ssr_iod; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ssr_iod + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.ssr_iod + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest.java b/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest.java index f0d2ea96d..0a07779b0 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBounds.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockBounds.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrOrbitClockBounds; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest { @@ -30,23 +34,15 @@ public class auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrOrbitClockBoundsTest.test1"); - byte[] payload = - new byte[] { - (byte) 180, (byte) 0, (byte) 0, (byte) 0, (byte) 3, (byte) 0, (byte) 1, - (byte) 2, (byte) 3, (byte) 48, (byte) 15, (byte) 1, (byte) 2, (byte) 24, - (byte) 39, (byte) 38, (byte) 37, (byte) 1, (byte) 2, (byte) 3, (byte) 39, - (byte) 1, (byte) 3, (byte) 39, (byte) 38, (byte) 37, (byte) 1, (byte) 2, - (byte) 3, (byte) 39, (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x05DE, payload); - MsgSsrOrbitClockBounds msg = new MsgSsrOrbitClockBounds(sbp); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)1,(byte)2,(byte)3,(byte)48,(byte)15,(byte)1,(byte)2,(byte)24,(byte)39,(byte)38,(byte)37,(byte)1,(byte)2,(byte)3,(byte)39,(byte)1,(byte)3,(byte)39,(byte)38,(byte)37,(byte)1,(byte)2,(byte)3,(byte)39,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x05DE, payload ); + MsgSsrOrbitClockBounds msg = new MsgSsrOrbitClockBounds( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.const_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.const_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.const_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -54,9 +50,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -64,9 +58,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -74,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.sol_id + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.header.sol_id + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -84,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.header.time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -94,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -104,9 +90,7 @@ public void test1() throws Throwable { } value = msg.header.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.update_interval + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.update_interval + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -114,8 +98,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -123,9 +106,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[0].clock_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[0].clock_bound_mu + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[0].clock_bound_mu + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -133,9 +114,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[0].clock_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[0].clock_bound_sig + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[0].clock_bound_sig + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -143,9 +122,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[0].orb_along_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[0].orb_along_bound_mu + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[0].orb_along_bound_mu + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -153,9 +130,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[0].orb_along_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[0].orb_along_bound_sig + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[0].orb_along_bound_sig + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -163,9 +138,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[0].orb_cross_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[0].orb_cross_bound_mu + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[0].orb_cross_bound_mu + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -173,9 +146,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[0].orb_cross_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[0].orb_cross_bound_sig + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[0].orb_cross_bound_sig + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -183,9 +154,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[0].orb_radial_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[0].orb_radial_bound_mu + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[0].orb_radial_bound_mu + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -193,9 +162,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[0].orb_radial_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[0].orb_radial_bound_sig + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[0].orb_radial_bound_sig + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -203,9 +170,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[0].sat_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[0].sat_id + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[0].sat_id + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -213,9 +178,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[1].clock_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[1].clock_bound_mu + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[1].clock_bound_mu + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -223,9 +186,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[1].clock_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[1].clock_bound_sig + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[1].clock_bound_sig + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -233,9 +194,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[1].orb_along_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[1].orb_along_bound_mu + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[1].orb_along_bound_mu + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -243,9 +202,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[1].orb_along_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[1].orb_along_bound_sig + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[1].orb_along_bound_sig + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -253,9 +210,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[1].orb_cross_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[1].orb_cross_bound_mu + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[1].orb_cross_bound_mu + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -263,9 +218,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[1].orb_cross_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[1].orb_cross_bound_sig + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[1].orb_cross_bound_sig + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -273,9 +226,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[1].orb_radial_bound_mu; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[1].orb_radial_bound_mu + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[1].orb_radial_bound_mu + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -283,9 +234,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[1].orb_radial_bound_sig; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[1].orb_radial_bound_sig + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[1].orb_radial_bound_sig + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -293,9 +242,7 @@ public void test1() throws Throwable { } value = msg.orbit_clock_bounds[1].sat_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.orbit_clock_bounds[1].sat_id + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.orbit_clock_bounds[1].sat_id + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -303,8 +250,7 @@ public void test1() throws Throwable { } value = msg.ssr_iod; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ssr_iod + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.ssr_iod + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockDepATest.java b/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockDepATest.java index 3ea85ea72..39859edcc 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockDepATest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockDepA.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClockDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrOrbitClockDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrOrbitClockDepATest { @@ -27,67 +32,17 @@ public class auto_check_sbp_ssr_MsgSsrOrbitClockDepATest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrOrbitClockDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 225, - (byte) 114, - (byte) 31, - (byte) 189, - (byte) 43, - (byte) 30, - (byte) 1, - (byte) 30, - (byte) 194, - (byte) 211, - (byte) 193, - (byte) 175, - (byte) 161, - (byte) 143, - (byte) 254, - (byte) 56, - (byte) 63, - (byte) 232, - (byte) 7, - (byte) 216, - (byte) 69, - (byte) 1, - (byte) 110, - (byte) 165, - (byte) 124, - (byte) 196, - (byte) 189, - (byte) 27, - (byte) 116, - (byte) 88, - (byte) 4, - (byte) 61, - (byte) 3, - (byte) 151, - (byte) 18, - (byte) 171, - (byte) 147, - (byte) 46, - (byte) 198, - (byte) 85, - (byte) 243, - (byte) 245, - (byte) 225, - (byte) 235, - (byte) 123, - (byte) 181, - (byte) 210, - }; - SBPMessage sbp = new SBPMessage(0xa621, 0x5dc, payload); - MsgSsrOrbitClockDepA msg = new MsgSsrOrbitClockDepA(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrOrbitClockDepATest.test1"); + byte[] payload = new byte[] {(byte)225,(byte)114,(byte)31,(byte)189,(byte)43,(byte)30,(byte)1,(byte)30,(byte)194,(byte)211,(byte)193,(byte)175,(byte)161,(byte)143,(byte)254,(byte)56,(byte)63,(byte)232,(byte)7,(byte)216,(byte)69,(byte)1,(byte)110,(byte)165,(byte)124,(byte)196,(byte)189,(byte)27,(byte)116,(byte)88,(byte)4,(byte)61,(byte)3,(byte)151,(byte)18,(byte)171,(byte)147,(byte)46,(byte)198,(byte)85,(byte)243,(byte)245,(byte)225,(byte)235,(byte)123,(byte)181,(byte)210, }; + SBPMessage sbp = new SBPMessage( 0xa621, 0x5dc, payload ); + MsgSsrOrbitClockDepA msg = new MsgSsrOrbitClockDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.along; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.along + "' != '" + 132661048 + "'", - value.equals(BigInteger.valueOf(132661048L))); + org.junit.Assert.assertTrue("'" + msg.along + "' != '" + 132661048 + "'", value.equals(BigInteger.valueOf( 132661048L ) ) ); } else { value = value.longValue(); expected = 132661048L; @@ -95,9 +50,7 @@ public void test1() throws Throwable { } value = msg.c0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.c0 + "' != '" + -970026069 + "'", - value.equals(BigInteger.valueOf(-970026069L))); + org.junit.Assert.assertTrue("'" + msg.c0 + "' != '" + -970026069 + "'", value.equals(BigInteger.valueOf( -970026069L ) ) ); } else { value = value.longValue(); expected = -970026069L; @@ -105,9 +58,7 @@ public void test1() throws Throwable { } value = msg.c1; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.c1 + "' != '" + -503975083 + "'", - value.equals(BigInteger.valueOf(-503975083L))); + org.junit.Assert.assertTrue("'" + msg.c1 + "' != '" + -503975083 + "'", value.equals(BigInteger.valueOf( -503975083L ) ) ); } else { value = value.longValue(); expected = -503975083L; @@ -115,9 +66,7 @@ public void test1() throws Throwable { } value = msg.c2; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.c2 + "' != '" + -759858197 + "'", - value.equals(BigInteger.valueOf(-759858197L))); + org.junit.Assert.assertTrue("'" + msg.c2 + "' != '" + -759858197 + "'", value.equals(BigInteger.valueOf( -759858197L ) ) ); } else { value = value.longValue(); expected = -759858197L; @@ -125,9 +74,7 @@ public void test1() throws Throwable { } value = msg.cross; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cross + "' != '" + 1845577176 + "'", - value.equals(BigInteger.valueOf(1845577176L))); + org.junit.Assert.assertTrue("'" + msg.cross + "' != '" + 1845577176 + "'", value.equals(BigInteger.valueOf( 1845577176L ) ) ); } else { value = value.longValue(); expected = 1845577176L; @@ -135,9 +82,7 @@ public void test1() throws Throwable { } value = msg.dot_along; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dot_along + "' != '" + 72905755 + "'", - value.equals(BigInteger.valueOf(72905755L))); + org.junit.Assert.assertTrue("'" + msg.dot_along + "' != '" + 72905755 + "'", value.equals(BigInteger.valueOf( 72905755L ) ) ); } else { value = value.longValue(); expected = 72905755L; @@ -145,9 +90,7 @@ public void test1() throws Throwable { } value = msg.dot_cross; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dot_cross + "' != '" + 311886653 + "'", - value.equals(BigInteger.valueOf(311886653L))); + org.junit.Assert.assertTrue("'" + msg.dot_cross + "' != '" + 311886653 + "'", value.equals(BigInteger.valueOf( 311886653L ) ) ); } else { value = value.longValue(); expected = 311886653L; @@ -155,9 +98,7 @@ public void test1() throws Throwable { } value = msg.dot_radial; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dot_radial + "' != '" + -1111196507 + "'", - value.equals(BigInteger.valueOf(-1111196507L))); + org.junit.Assert.assertTrue("'" + msg.dot_radial + "' != '" + -1111196507 + "'", value.equals(BigInteger.valueOf( -1111196507L ) ) ); } else { value = value.longValue(); expected = -1111196507L; @@ -165,8 +106,7 @@ public void test1() throws Throwable { } value = msg.iod; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.iod + "' != '" + 193 + "'", value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.iod + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -174,9 +114,7 @@ public void test1() throws Throwable { } value = msg.iod_ssr; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.iod_ssr + "' != '" + 211 + "'", - value.equals(BigInteger.valueOf(211L))); + org.junit.Assert.assertTrue("'" + msg.iod_ssr + "' != '" + 211 + "'", value.equals(BigInteger.valueOf( 211L ) ) ); } else { value = value.longValue(); expected = 211L; @@ -184,9 +122,7 @@ public void test1() throws Throwable { } value = msg.radial; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.radial + "' != '" + -24141393 + "'", - value.equals(BigInteger.valueOf(-24141393L))); + org.junit.Assert.assertTrue("'" + msg.radial + "' != '" + -24141393 + "'", value.equals(BigInteger.valueOf( -24141393L ) ) ); } else { value = value.longValue(); expected = -24141393L; @@ -194,9 +130,7 @@ public void test1() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -204,8 +138,7 @@ public void test1() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -213,9 +146,7 @@ public void test1() throws Throwable { } value = msg.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time.tow + "' != '" + 3172954849L + "'", - value.equals(new BigInteger("3172954849"))); + org.junit.Assert.assertTrue("'" + msg.time.tow + "' != '" + 3172954849L + "'", value.equals( new BigInteger( "3172954849" ) ) ); } else { value = value.longValue(); expected = 3172954849L; @@ -223,9 +154,7 @@ public void test1() throws Throwable { } value = msg.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time.wn + "' != '" + 7723 + "'", - value.equals(BigInteger.valueOf(7723L))); + org.junit.Assert.assertTrue("'" + msg.time.wn + "' != '" + 7723 + "'", value.equals(BigInteger.valueOf( 7723L ) ) ); } else { value = value.longValue(); expected = 7723L; @@ -233,9 +162,7 @@ public void test1() throws Throwable { } value = msg.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.update_interval + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.update_interval + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockTest.java b/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockTest.java index 817af6f90..c85c2fb2e 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrOrbitClockTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClock.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrOrbitClock.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrOrbitClock; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrOrbitClockTest { @@ -27,70 +32,17 @@ public class auto_check_sbp_ssr_MsgSsrOrbitClockTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrOrbitClockTest.test1"); - byte[] payload = - new byte[] { - (byte) 83, - (byte) 208, - (byte) 102, - (byte) 207, - (byte) 164, - (byte) 29, - (byte) 203, - (byte) 212, - (byte) 236, - (byte) 255, - (byte) 152, - (byte) 233, - (byte) 207, - (byte) 55, - (byte) 94, - (byte) 54, - (byte) 58, - (byte) 128, - (byte) 68, - (byte) 27, - (byte) 117, - (byte) 176, - (byte) 110, - (byte) 251, - (byte) 61, - (byte) 244, - (byte) 122, - (byte) 50, - (byte) 95, - (byte) 52, - (byte) 144, - (byte) 232, - (byte) 24, - (byte) 10, - (byte) 37, - (byte) 127, - (byte) 163, - (byte) 66, - (byte) 177, - (byte) 105, - (byte) 156, - (byte) 245, - (byte) 10, - (byte) 249, - (byte) 107, - (byte) 218, - (byte) 17, - (byte) 186, - (byte) 56, - (byte) 72, - }; - SBPMessage sbp = new SBPMessage(0xe535, 0x5dd, payload); - MsgSsrOrbitClock msg = new MsgSsrOrbitClock(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrOrbitClockTest.test1"); + byte[] payload = new byte[] {(byte)83,(byte)208,(byte)102,(byte)207,(byte)164,(byte)29,(byte)203,(byte)212,(byte)236,(byte)255,(byte)152,(byte)233,(byte)207,(byte)55,(byte)94,(byte)54,(byte)58,(byte)128,(byte)68,(byte)27,(byte)117,(byte)176,(byte)110,(byte)251,(byte)61,(byte)244,(byte)122,(byte)50,(byte)95,(byte)52,(byte)144,(byte)232,(byte)24,(byte)10,(byte)37,(byte)127,(byte)163,(byte)66,(byte)177,(byte)105,(byte)156,(byte)245,(byte)10,(byte)249,(byte)107,(byte)218,(byte)17,(byte)186,(byte)56,(byte)72, }; + SBPMessage sbp = new SBPMessage( 0xe535, 0x5dd, payload ); + MsgSsrOrbitClock msg = new MsgSsrOrbitClock( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.along; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.along + "' != '" + -1334502588 + "'", - value.equals(BigInteger.valueOf(-1334502588L))); + org.junit.Assert.assertTrue("'" + msg.along + "' != '" + -1334502588 + "'", value.equals(BigInteger.valueOf( -1334502588L ) ) ); } else { value = value.longValue(); expected = -1334502588L; @@ -98,9 +50,7 @@ public void test1() throws Throwable { } value = msg.c0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.c0 + "' != '" + -174298703 + "'", - value.equals(BigInteger.valueOf(-174298703L))); + org.junit.Assert.assertTrue("'" + msg.c0 + "' != '" + -174298703 + "'", value.equals(BigInteger.valueOf( -174298703L ) ) ); } else { value = value.longValue(); expected = -174298703L; @@ -108,9 +58,7 @@ public void test1() throws Throwable { } value = msg.c1; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.c1 + "' != '" + -630458102 + "'", - value.equals(BigInteger.valueOf(-630458102L))); + org.junit.Assert.assertTrue("'" + msg.c1 + "' != '" + -630458102 + "'", value.equals(BigInteger.valueOf( -630458102L ) ) ); } else { value = value.longValue(); expected = -630458102L; @@ -118,9 +66,7 @@ public void test1() throws Throwable { } value = msg.c2; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.c2 + "' != '" + 1211677201 + "'", - value.equals(BigInteger.valueOf(1211677201L))); + org.junit.Assert.assertTrue("'" + msg.c2 + "' != '" + 1211677201 + "'", value.equals(BigInteger.valueOf( 1211677201L ) ) ); } else { value = value.longValue(); expected = 1211677201L; @@ -128,9 +74,7 @@ public void test1() throws Throwable { } value = msg.cross; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cross + "' != '" + -197264530 + "'", - value.equals(BigInteger.valueOf(-197264530L))); + org.junit.Assert.assertTrue("'" + msg.cross + "' != '" + -197264530 + "'", value.equals(BigInteger.valueOf( -197264530L ) ) ); } else { value = value.longValue(); expected = -197264530L; @@ -138,9 +82,7 @@ public void test1() throws Throwable { } value = msg.dot_along; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dot_along + "' != '" + 169404560 + "'", - value.equals(BigInteger.valueOf(169404560L))); + org.junit.Assert.assertTrue("'" + msg.dot_along + "' != '" + 169404560 + "'", value.equals(BigInteger.valueOf( 169404560L ) ) ); } else { value = value.longValue(); expected = 169404560L; @@ -148,9 +90,7 @@ public void test1() throws Throwable { } value = msg.dot_cross; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dot_cross + "' != '" + 1118011173 + "'", - value.equals(BigInteger.valueOf(1118011173L))); + org.junit.Assert.assertTrue("'" + msg.dot_cross + "' != '" + 1118011173 + "'", value.equals(BigInteger.valueOf( 1118011173L ) ) ); } else { value = value.longValue(); expected = 1118011173L; @@ -158,9 +98,7 @@ public void test1() throws Throwable { } value = msg.dot_radial; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dot_radial + "' != '" + 878654074 + "'", - value.equals(BigInteger.valueOf(878654074L))); + org.junit.Assert.assertTrue("'" + msg.dot_radial + "' != '" + 878654074 + "'", value.equals(BigInteger.valueOf( 878654074L ) ) ); } else { value = value.longValue(); expected = 878654074L; @@ -168,9 +106,7 @@ public void test1() throws Throwable { } value = msg.iod; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.iod + "' != '" + 936372632 + "'", - value.equals(BigInteger.valueOf(936372632L))); + org.junit.Assert.assertTrue("'" + msg.iod + "' != '" + 936372632 + "'", value.equals(BigInteger.valueOf( 936372632L ) ) ); } else { value = value.longValue(); expected = 936372632L; @@ -178,9 +114,7 @@ public void test1() throws Throwable { } value = msg.iod_ssr; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.iod_ssr + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.iod_ssr + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -188,9 +122,7 @@ public void test1() throws Throwable { } value = msg.radial; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.radial + "' != '" + -2143668642 + "'", - value.equals(BigInteger.valueOf(-2143668642L))); + org.junit.Assert.assertTrue("'" + msg.radial + "' != '" + -2143668642 + "'", value.equals(BigInteger.valueOf( -2143668642L ) ) ); } else { value = value.longValue(); expected = -2143668642L; @@ -198,9 +130,7 @@ public void test1() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -208,9 +138,7 @@ public void test1() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -218,9 +146,7 @@ public void test1() throws Throwable { } value = msg.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time.tow + "' != '" + 3479621715L + "'", - value.equals(new BigInteger("3479621715"))); + org.junit.Assert.assertTrue("'" + msg.time.tow + "' != '" + 3479621715L + "'", value.equals( new BigInteger( "3479621715" ) ) ); } else { value = value.longValue(); expected = 3479621715L; @@ -228,9 +154,7 @@ public void test1() throws Throwable { } value = msg.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time.wn + "' != '" + 7588 + "'", - value.equals(BigInteger.valueOf(7588L))); + org.junit.Assert.assertTrue("'" + msg.time.wn + "' != '" + 7588 + "'", value.equals(BigInteger.valueOf( 7588L ) ) ); } else { value = value.longValue(); expected = 7588L; @@ -238,9 +162,7 @@ public void test1() throws Throwable { } value = msg.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.update_interval + "' != '" + 236 + "'", - value.equals(BigInteger.valueOf(236L))); + org.junit.Assert.assertTrue("'" + msg.update_interval + "' != '" + 236 + "'", value.equals(BigInteger.valueOf( 236L ) ) ); } else { value = value.longValue(); expected = 236L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrPhaseBiasesTest.java b/java/test/auto_check_sbp_ssr_MsgSsrPhaseBiasesTest.java index 245b3740a..52ea80df8 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrPhaseBiasesTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrPhaseBiasesTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrPhaseBiases.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrPhaseBiases.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrPhaseBiases; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrPhaseBiasesTest { @@ -27,275 +32,17 @@ public class auto_check_sbp_ssr_MsgSsrPhaseBiasesTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrPhaseBiasesTest.test1"); - byte[] payload = - new byte[] { - (byte) 209, - (byte) 154, - (byte) 144, - (byte) 12, - (byte) 213, - (byte) 164, - (byte) 169, - (byte) 82, - (byte) 177, - (byte) 230, - (byte) 98, - (byte) 209, - (byte) 249, - (byte) 22, - (byte) 17, - (byte) 29, - (byte) 250, - (byte) 245, - (byte) 193, - (byte) 219, - (byte) 30, - (byte) 212, - (byte) 177, - (byte) 207, - (byte) 187, - (byte) 33, - (byte) 146, - (byte) 58, - (byte) 204, - (byte) 164, - (byte) 65, - (byte) 114, - (byte) 49, - (byte) 248, - (byte) 52, - (byte) 8, - (byte) 161, - (byte) 44, - (byte) 252, - (byte) 166, - (byte) 168, - (byte) 232, - (byte) 124, - (byte) 134, - (byte) 86, - (byte) 173, - (byte) 241, - (byte) 174, - (byte) 44, - (byte) 142, - (byte) 155, - (byte) 129, - (byte) 143, - (byte) 184, - (byte) 161, - (byte) 211, - (byte) 15, - (byte) 36, - (byte) 189, - (byte) 208, - (byte) 194, - (byte) 221, - (byte) 152, - (byte) 16, - (byte) 203, - (byte) 87, - (byte) 34, - (byte) 188, - (byte) 141, - (byte) 104, - (byte) 189, - (byte) 102, - (byte) 156, - (byte) 252, - (byte) 22, - (byte) 251, - (byte) 136, - (byte) 49, - (byte) 188, - (byte) 157, - (byte) 222, - (byte) 245, - (byte) 49, - (byte) 132, - (byte) 16, - (byte) 34, - (byte) 142, - (byte) 228, - (byte) 85, - (byte) 139, - (byte) 221, - (byte) 197, - (byte) 235, - (byte) 98, - (byte) 74, - (byte) 107, - (byte) 70, - (byte) 36, - (byte) 38, - (byte) 239, - (byte) 251, - (byte) 112, - (byte) 188, - (byte) 124, - (byte) 246, - (byte) 141, - (byte) 164, - (byte) 150, - (byte) 104, - (byte) 7, - (byte) 213, - (byte) 44, - (byte) 21, - (byte) 244, - (byte) 192, - (byte) 4, - (byte) 143, - (byte) 24, - (byte) 42, - (byte) 21, - (byte) 84, - (byte) 136, - (byte) 7, - (byte) 42, - (byte) 118, - (byte) 45, - (byte) 23, - (byte) 174, - (byte) 175, - (byte) 129, - (byte) 54, - (byte) 169, - (byte) 14, - (byte) 213, - (byte) 2, - (byte) 197, - (byte) 98, - (byte) 60, - (byte) 13, - (byte) 207, - (byte) 105, - (byte) 100, - (byte) 129, - (byte) 72, - (byte) 136, - (byte) 240, - (byte) 140, - (byte) 129, - (byte) 9, - (byte) 114, - (byte) 172, - (byte) 151, - (byte) 150, - (byte) 17, - (byte) 210, - (byte) 127, - (byte) 115, - (byte) 151, - (byte) 3, - (byte) 242, - (byte) 254, - (byte) 215, - (byte) 14, - (byte) 5, - (byte) 34, - (byte) 126, - (byte) 2, - (byte) 215, - (byte) 65, - (byte) 38, - (byte) 176, - (byte) 23, - (byte) 210, - (byte) 201, - (byte) 97, - (byte) 36, - (byte) 207, - (byte) 92, - (byte) 224, - (byte) 26, - (byte) 116, - (byte) 155, - (byte) 211, - (byte) 165, - (byte) 47, - (byte) 102, - (byte) 38, - (byte) 67, - (byte) 199, - (byte) 55, - (byte) 117, - (byte) 36, - (byte) 169, - (byte) 33, - (byte) 1, - (byte) 230, - (byte) 201, - (byte) 183, - (byte) 21, - (byte) 42, - (byte) 62, - (byte) 147, - (byte) 173, - (byte) 173, - (byte) 155, - (byte) 98, - (byte) 146, - (byte) 231, - (byte) 167, - (byte) 138, - (byte) 82, - (byte) 167, - (byte) 127, - (byte) 229, - (byte) 1, - (byte) 2, - (byte) 127, - (byte) 237, - (byte) 207, - (byte) 116, - (byte) 90, - (byte) 115, - (byte) 159, - (byte) 3, - (byte) 42, - (byte) 66, - (byte) 145, - (byte) 250, - (byte) 201, - (byte) 7, - (byte) 251, - (byte) 2, - (byte) 75, - (byte) 230, - (byte) 26, - (byte) 213, - (byte) 181, - (byte) 56, - (byte) 64, - (byte) 97, - (byte) 88, - (byte) 255, - (byte) 6, - (byte) 147, - (byte) 16, - (byte) 89, - (byte) 203, - (byte) 27, - (byte) 68, - (byte) 243, - (byte) 230, - (byte) 55, - (byte) 242, - (byte) 167, - (byte) 169, - }; - SBPMessage sbp = new SBPMessage(0xcedb, 0x5e6, payload); - MsgSsrPhaseBiases msg = new MsgSsrPhaseBiases(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrPhaseBiasesTest.test1"); + byte[] payload = new byte[] {(byte)209,(byte)154,(byte)144,(byte)12,(byte)213,(byte)164,(byte)169,(byte)82,(byte)177,(byte)230,(byte)98,(byte)209,(byte)249,(byte)22,(byte)17,(byte)29,(byte)250,(byte)245,(byte)193,(byte)219,(byte)30,(byte)212,(byte)177,(byte)207,(byte)187,(byte)33,(byte)146,(byte)58,(byte)204,(byte)164,(byte)65,(byte)114,(byte)49,(byte)248,(byte)52,(byte)8,(byte)161,(byte)44,(byte)252,(byte)166,(byte)168,(byte)232,(byte)124,(byte)134,(byte)86,(byte)173,(byte)241,(byte)174,(byte)44,(byte)142,(byte)155,(byte)129,(byte)143,(byte)184,(byte)161,(byte)211,(byte)15,(byte)36,(byte)189,(byte)208,(byte)194,(byte)221,(byte)152,(byte)16,(byte)203,(byte)87,(byte)34,(byte)188,(byte)141,(byte)104,(byte)189,(byte)102,(byte)156,(byte)252,(byte)22,(byte)251,(byte)136,(byte)49,(byte)188,(byte)157,(byte)222,(byte)245,(byte)49,(byte)132,(byte)16,(byte)34,(byte)142,(byte)228,(byte)85,(byte)139,(byte)221,(byte)197,(byte)235,(byte)98,(byte)74,(byte)107,(byte)70,(byte)36,(byte)38,(byte)239,(byte)251,(byte)112,(byte)188,(byte)124,(byte)246,(byte)141,(byte)164,(byte)150,(byte)104,(byte)7,(byte)213,(byte)44,(byte)21,(byte)244,(byte)192,(byte)4,(byte)143,(byte)24,(byte)42,(byte)21,(byte)84,(byte)136,(byte)7,(byte)42,(byte)118,(byte)45,(byte)23,(byte)174,(byte)175,(byte)129,(byte)54,(byte)169,(byte)14,(byte)213,(byte)2,(byte)197,(byte)98,(byte)60,(byte)13,(byte)207,(byte)105,(byte)100,(byte)129,(byte)72,(byte)136,(byte)240,(byte)140,(byte)129,(byte)9,(byte)114,(byte)172,(byte)151,(byte)150,(byte)17,(byte)210,(byte)127,(byte)115,(byte)151,(byte)3,(byte)242,(byte)254,(byte)215,(byte)14,(byte)5,(byte)34,(byte)126,(byte)2,(byte)215,(byte)65,(byte)38,(byte)176,(byte)23,(byte)210,(byte)201,(byte)97,(byte)36,(byte)207,(byte)92,(byte)224,(byte)26,(byte)116,(byte)155,(byte)211,(byte)165,(byte)47,(byte)102,(byte)38,(byte)67,(byte)199,(byte)55,(byte)117,(byte)36,(byte)169,(byte)33,(byte)1,(byte)230,(byte)201,(byte)183,(byte)21,(byte)42,(byte)62,(byte)147,(byte)173,(byte)173,(byte)155,(byte)98,(byte)146,(byte)231,(byte)167,(byte)138,(byte)82,(byte)167,(byte)127,(byte)229,(byte)1,(byte)2,(byte)127,(byte)237,(byte)207,(byte)116,(byte)90,(byte)115,(byte)159,(byte)3,(byte)42,(byte)66,(byte)145,(byte)250,(byte)201,(byte)7,(byte)251,(byte)2,(byte)75,(byte)230,(byte)26,(byte)213,(byte)181,(byte)56,(byte)64,(byte)97,(byte)88,(byte)255,(byte)6,(byte)147,(byte)16,(byte)89,(byte)203,(byte)27,(byte)68,(byte)243,(byte)230,(byte)55,(byte)242,(byte)167,(byte)169, }; + SBPMessage sbp = new SBPMessage( 0xcedb, 0x5e6, payload ); + MsgSsrPhaseBiases msg = new MsgSsrPhaseBiases( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.biases[0].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[0].bias + "' != '" + -1311498533 + "'", - value.equals(BigInteger.valueOf(-1311498533L))); + org.junit.Assert.assertTrue("'" + msg.biases[0].bias + "' != '" + -1311498533 + "'", value.equals(BigInteger.valueOf( -1311498533L ) ) ); } else { value = value.longValue(); expected = -1311498533L; @@ -303,9 +50,7 @@ public void test1() throws Throwable { } value = msg.biases[0].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[0].code + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.biases[0].code + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -313,9 +58,7 @@ public void test1() throws Throwable { } value = msg.biases[0].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[0].discontinuity_counter + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.biases[0].discontinuity_counter + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -323,9 +66,7 @@ public void test1() throws Throwable { } value = msg.biases[0].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[0].integer_indicator + "' != '" + 250 + "'", - value.equals(BigInteger.valueOf(250L))); + org.junit.Assert.assertTrue("'" + msg.biases[0].integer_indicator + "' != '" + 250 + "'", value.equals(BigInteger.valueOf( 250L ) ) ); } else { value = value.longValue(); expected = 250L; @@ -333,9 +74,7 @@ public void test1() throws Throwable { } value = msg.biases[0].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[0].widelane_integer_indicator + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.biases[0].widelane_integer_indicator + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -343,9 +82,7 @@ public void test1() throws Throwable { } value = msg.biases[1].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[1].bias + "' != '" + 1101319226 + "'", - value.equals(BigInteger.valueOf(1101319226L))); + org.junit.Assert.assertTrue("'" + msg.biases[1].bias + "' != '" + 1101319226 + "'", value.equals(BigInteger.valueOf( 1101319226L ) ) ); } else { value = value.longValue(); expected = 1101319226L; @@ -353,9 +90,7 @@ public void test1() throws Throwable { } value = msg.biases[1].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[1].code + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.biases[1].code + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -363,9 +98,7 @@ public void test1() throws Throwable { } value = msg.biases[1].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[1].discontinuity_counter + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.biases[1].discontinuity_counter + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -373,9 +106,7 @@ public void test1() throws Throwable { } value = msg.biases[1].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[1].integer_indicator + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.biases[1].integer_indicator + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -383,9 +114,7 @@ public void test1() throws Throwable { } value = msg.biases[1].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[1].widelane_integer_indicator + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.biases[1].widelane_integer_indicator + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -393,9 +122,7 @@ public void test1() throws Throwable { } value = msg.biases[2].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[2].bias + "' != '" + -64184056 + "'", - value.equals(BigInteger.valueOf(-64184056L))); + org.junit.Assert.assertTrue("'" + msg.biases[2].bias + "' != '" + -64184056 + "'", value.equals(BigInteger.valueOf( -64184056L ) ) ); } else { value = value.longValue(); expected = -64184056L; @@ -403,9 +130,7 @@ public void test1() throws Throwable { } value = msg.biases[2].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[2].code + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.biases[2].code + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -413,9 +138,7 @@ public void test1() throws Throwable { } value = msg.biases[2].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[2].discontinuity_counter + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.biases[2].discontinuity_counter + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -423,9 +146,7 @@ public void test1() throws Throwable { } value = msg.biases[2].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[2].integer_indicator + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.biases[2].integer_indicator + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -433,9 +154,7 @@ public void test1() throws Throwable { } value = msg.biases[2].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[2].widelane_integer_indicator + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.biases[2].widelane_integer_indicator + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -443,9 +162,7 @@ public void test1() throws Throwable { } value = msg.biases[3].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[3].bias + "' != '" + -240298362 + "'", - value.equals(BigInteger.valueOf(-240298362L))); + org.junit.Assert.assertTrue("'" + msg.biases[3].bias + "' != '" + -240298362 + "'", value.equals(BigInteger.valueOf( -240298362L ) ) ); } else { value = value.longValue(); expected = -240298362L; @@ -453,9 +170,7 @@ public void test1() throws Throwable { } value = msg.biases[3].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[3].code + "' != '" + 166 + "'", - value.equals(BigInteger.valueOf(166L))); + org.junit.Assert.assertTrue("'" + msg.biases[3].code + "' != '" + 166 + "'", value.equals(BigInteger.valueOf( 166L ) ) ); } else { value = value.longValue(); expected = 166L; @@ -463,9 +178,7 @@ public void test1() throws Throwable { } value = msg.biases[3].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[3].discontinuity_counter + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.biases[3].discontinuity_counter + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -473,9 +186,7 @@ public void test1() throws Throwable { } value = msg.biases[3].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[3].integer_indicator + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.biases[3].integer_indicator + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -483,9 +194,7 @@ public void test1() throws Throwable { } value = msg.biases[3].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[3].widelane_integer_indicator + "' != '" + 232 + "'", - value.equals(BigInteger.valueOf(232L))); + org.junit.Assert.assertTrue("'" + msg.biases[3].widelane_integer_indicator + "' != '" + 232 + "'", value.equals(BigInteger.valueOf( 232L ) ) ); } else { value = value.longValue(); expected = 232L; @@ -493,9 +202,7 @@ public void test1() throws Throwable { } value = msg.biases[4].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[4].bias + "' != '" + -1581740159 + "'", - value.equals(BigInteger.valueOf(-1581740159L))); + org.junit.Assert.assertTrue("'" + msg.biases[4].bias + "' != '" + -1581740159 + "'", value.equals(BigInteger.valueOf( -1581740159L ) ) ); } else { value = value.longValue(); expected = -1581740159L; @@ -503,9 +210,7 @@ public void test1() throws Throwable { } value = msg.biases[4].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[4].code + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.biases[4].code + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -513,9 +218,7 @@ public void test1() throws Throwable { } value = msg.biases[4].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[4].discontinuity_counter + "' != '" + 155 + "'", - value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.biases[4].discontinuity_counter + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -523,9 +226,7 @@ public void test1() throws Throwable { } value = msg.biases[4].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[4].integer_indicator + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.biases[4].integer_indicator + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -533,9 +234,7 @@ public void test1() throws Throwable { } value = msg.biases[4].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[4].widelane_integer_indicator + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.biases[4].widelane_integer_indicator + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -543,9 +242,7 @@ public void test1() throws Throwable { } value = msg.biases[5].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[5].bias + "' != '" + -1730297136 + "'", - value.equals(BigInteger.valueOf(-1730297136L))); + org.junit.Assert.assertTrue("'" + msg.biases[5].bias + "' != '" + -1730297136 + "'", value.equals(BigInteger.valueOf( -1730297136L ) ) ); } else { value = value.longValue(); expected = -1730297136L; @@ -553,9 +250,7 @@ public void test1() throws Throwable { } value = msg.biases[5].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[5].code + "' != '" + 211 + "'", - value.equals(BigInteger.valueOf(211L))); + org.junit.Assert.assertTrue("'" + msg.biases[5].code + "' != '" + 211 + "'", value.equals(BigInteger.valueOf( 211L ) ) ); } else { value = value.longValue(); expected = 211L; @@ -563,9 +258,7 @@ public void test1() throws Throwable { } value = msg.biases[5].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[5].discontinuity_counter + "' != '" + 189 + "'", - value.equals(BigInteger.valueOf(189L))); + org.junit.Assert.assertTrue("'" + msg.biases[5].discontinuity_counter + "' != '" + 189 + "'", value.equals(BigInteger.valueOf( 189L ) ) ); } else { value = value.longValue(); expected = 189L; @@ -573,9 +266,7 @@ public void test1() throws Throwable { } value = msg.biases[5].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[5].integer_indicator + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.biases[5].integer_indicator + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -583,9 +274,7 @@ public void test1() throws Throwable { } value = msg.biases[5].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[5].widelane_integer_indicator + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.biases[5].widelane_integer_indicator + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -593,9 +282,7 @@ public void test1() throws Throwable { } value = msg.biases[6].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[6].bias + "' != '" + -1117221444 + "'", - value.equals(BigInteger.valueOf(-1117221444L))); + org.junit.Assert.assertTrue("'" + msg.biases[6].bias + "' != '" + -1117221444 + "'", value.equals(BigInteger.valueOf( -1117221444L ) ) ); } else { value = value.longValue(); expected = -1117221444L; @@ -603,9 +290,7 @@ public void test1() throws Throwable { } value = msg.biases[6].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[6].code + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.biases[6].code + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -613,9 +298,7 @@ public void test1() throws Throwable { } value = msg.biases[6].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[6].discontinuity_counter + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.biases[6].discontinuity_counter + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -623,9 +306,7 @@ public void test1() throws Throwable { } value = msg.biases[6].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[6].integer_indicator + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.biases[6].integer_indicator + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -633,9 +314,7 @@ public void test1() throws Throwable { } value = msg.biases[6].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[6].widelane_integer_indicator + "' != '" + 87 + "'", - value.equals(BigInteger.valueOf(87L))); + org.junit.Assert.assertTrue("'" + msg.biases[6].widelane_integer_indicator + "' != '" + 87 + "'", value.equals(BigInteger.valueOf( 87L ) ) ); } else { value = value.longValue(); expected = 87L; @@ -643,9 +322,7 @@ public void test1() throws Throwable { } value = msg.biases[7].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[7].bias + "' != '" + -1137604357 + "'", - value.equals(BigInteger.valueOf(-1137604357L))); + org.junit.Assert.assertTrue("'" + msg.biases[7].bias + "' != '" + -1137604357 + "'", value.equals(BigInteger.valueOf( -1137604357L ) ) ); } else { value = value.longValue(); expected = -1137604357L; @@ -653,9 +330,7 @@ public void test1() throws Throwable { } value = msg.biases[7].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[7].code + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.biases[7].code + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -663,9 +338,7 @@ public void test1() throws Throwable { } value = msg.biases[7].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[7].discontinuity_counter + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.biases[7].discontinuity_counter + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -673,9 +346,7 @@ public void test1() throws Throwable { } value = msg.biases[7].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[7].integer_indicator + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.biases[7].integer_indicator + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -683,9 +354,7 @@ public void test1() throws Throwable { } value = msg.biases[7].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[7].widelane_integer_indicator + "' != '" + 252 + "'", - value.equals(BigInteger.valueOf(252L))); + org.junit.Assert.assertTrue("'" + msg.biases[7].widelane_integer_indicator + "' != '" + 252 + "'", value.equals(BigInteger.valueOf( 252L ) ) ); } else { value = value.longValue(); expected = 252L; @@ -693,9 +362,7 @@ public void test1() throws Throwable { } value = msg.biases[8].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[8].bias + "' != '" + -1910370172 + "'", - value.equals(BigInteger.valueOf(-1910370172L))); + org.junit.Assert.assertTrue("'" + msg.biases[8].bias + "' != '" + -1910370172 + "'", value.equals(BigInteger.valueOf( -1910370172L ) ) ); } else { value = value.longValue(); expected = -1910370172L; @@ -703,9 +370,7 @@ public void test1() throws Throwable { } value = msg.biases[8].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[8].code + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.biases[8].code + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -713,9 +378,7 @@ public void test1() throws Throwable { } value = msg.biases[8].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[8].discontinuity_counter + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.biases[8].discontinuity_counter + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -723,9 +386,7 @@ public void test1() throws Throwable { } value = msg.biases[8].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[8].integer_indicator + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.biases[8].integer_indicator + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -733,9 +394,7 @@ public void test1() throws Throwable { } value = msg.biases[8].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[8].widelane_integer_indicator + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.biases[8].widelane_integer_indicator + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -743,9 +402,7 @@ public void test1() throws Throwable { } value = msg.biases[9].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[9].bias + "' != '" + 1247996869 + "'", - value.equals(BigInteger.valueOf(1247996869L))); + org.junit.Assert.assertTrue("'" + msg.biases[9].bias + "' != '" + 1247996869 + "'", value.equals(BigInteger.valueOf( 1247996869L ) ) ); } else { value = value.longValue(); expected = 1247996869L; @@ -753,9 +410,7 @@ public void test1() throws Throwable { } value = msg.biases[9].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[9].code + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.biases[9].code + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -763,9 +418,7 @@ public void test1() throws Throwable { } value = msg.biases[9].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[9].discontinuity_counter + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.biases[9].discontinuity_counter + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -773,9 +426,7 @@ public void test1() throws Throwable { } value = msg.biases[9].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[9].integer_indicator + "' != '" + 85 + "'", - value.equals(BigInteger.valueOf(85L))); + org.junit.Assert.assertTrue("'" + msg.biases[9].integer_indicator + "' != '" + 85 + "'", value.equals(BigInteger.valueOf( 85L ) ) ); } else { value = value.longValue(); expected = 85L; @@ -783,9 +434,7 @@ public void test1() throws Throwable { } value = msg.biases[9].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[9].widelane_integer_indicator + "' != '" + 139 + "'", - value.equals(BigInteger.valueOf(139L))); + org.junit.Assert.assertTrue("'" + msg.biases[9].widelane_integer_indicator + "' != '" + 139 + "'", value.equals(BigInteger.valueOf( 139L ) ) ); } else { value = value.longValue(); expected = 139L; @@ -793,9 +442,7 @@ public void test1() throws Throwable { } value = msg.biases[10].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[10].bias + "' != '" + -1133446161 + "'", - value.equals(BigInteger.valueOf(-1133446161L))); + org.junit.Assert.assertTrue("'" + msg.biases[10].bias + "' != '" + -1133446161 + "'", value.equals(BigInteger.valueOf( -1133446161L ) ) ); } else { value = value.longValue(); expected = -1133446161L; @@ -803,9 +450,7 @@ public void test1() throws Throwable { } value = msg.biases[10].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[10].code + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.biases[10].code + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -813,9 +458,7 @@ public void test1() throws Throwable { } value = msg.biases[10].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[10].discontinuity_counter + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.biases[10].discontinuity_counter + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -823,9 +466,7 @@ public void test1() throws Throwable { } value = msg.biases[10].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[10].integer_indicator + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.biases[10].integer_indicator + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -833,9 +474,7 @@ public void test1() throws Throwable { } value = msg.biases[10].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[10].widelane_integer_indicator + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.biases[10].widelane_integer_indicator + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -843,9 +482,7 @@ public void test1() throws Throwable { } value = msg.biases[11].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[11].bias + "' != '" + -720934762 + "'", - value.equals(BigInteger.valueOf(-720934762L))); + org.junit.Assert.assertTrue("'" + msg.biases[11].bias + "' != '" + -720934762 + "'", value.equals(BigInteger.valueOf( -720934762L ) ) ); } else { value = value.longValue(); expected = -720934762L; @@ -853,9 +490,7 @@ public void test1() throws Throwable { } value = msg.biases[11].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[11].code + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.biases[11].code + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -863,9 +498,7 @@ public void test1() throws Throwable { } value = msg.biases[11].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[11].discontinuity_counter + "' != '" + 164 + "'", - value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.biases[11].discontinuity_counter + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -873,9 +506,7 @@ public void test1() throws Throwable { } value = msg.biases[11].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[11].integer_indicator + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.biases[11].integer_indicator + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -883,9 +514,7 @@ public void test1() throws Throwable { } value = msg.biases[11].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[11].widelane_integer_indicator + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.biases[11].widelane_integer_indicator + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -893,9 +522,7 @@ public void test1() throws Throwable { } value = msg.biases[12].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[12].bias + "' != '" + 706252548 + "'", - value.equals(BigInteger.valueOf(706252548L))); + org.junit.Assert.assertTrue("'" + msg.biases[12].bias + "' != '" + 706252548 + "'", value.equals(BigInteger.valueOf( 706252548L ) ) ); } else { value = value.longValue(); expected = 706252548L; @@ -903,9 +530,7 @@ public void test1() throws Throwable { } value = msg.biases[12].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[12].code + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.biases[12].code + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -913,9 +538,7 @@ public void test1() throws Throwable { } value = msg.biases[12].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[12].discontinuity_counter + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.biases[12].discontinuity_counter + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -923,9 +546,7 @@ public void test1() throws Throwable { } value = msg.biases[12].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[12].integer_indicator + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.biases[12].integer_indicator + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -933,9 +554,7 @@ public void test1() throws Throwable { } value = msg.biases[12].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[12].widelane_integer_indicator + "' != '" + 244 + "'", - value.equals(BigInteger.valueOf(244L))); + org.junit.Assert.assertTrue("'" + msg.biases[12].widelane_integer_indicator + "' != '" + 244 + "'", value.equals(BigInteger.valueOf( 244L ) ) ); } else { value = value.longValue(); expected = 244L; @@ -943,9 +562,7 @@ public void test1() throws Throwable { } value = msg.biases[13].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[13].bias + "' != '" + 388855338 + "'", - value.equals(BigInteger.valueOf(388855338L))); + org.junit.Assert.assertTrue("'" + msg.biases[13].bias + "' != '" + 388855338 + "'", value.equals(BigInteger.valueOf( 388855338L ) ) ); } else { value = value.longValue(); expected = 388855338L; @@ -953,9 +570,7 @@ public void test1() throws Throwable { } value = msg.biases[13].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[13].code + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.biases[13].code + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -963,9 +578,7 @@ public void test1() throws Throwable { } value = msg.biases[13].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[13].discontinuity_counter + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.biases[13].discontinuity_counter + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -973,9 +586,7 @@ public void test1() throws Throwable { } value = msg.biases[13].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[13].integer_indicator + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.biases[13].integer_indicator + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -983,9 +594,7 @@ public void test1() throws Throwable { } value = msg.biases[13].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[13].widelane_integer_indicator + "' != '" + 136 + "'", - value.equals(BigInteger.valueOf(136L))); + org.junit.Assert.assertTrue("'" + msg.biases[13].widelane_integer_indicator + "' != '" + 136 + "'", value.equals(BigInteger.valueOf( 136L ) ) ); } else { value = value.longValue(); expected = 136L; @@ -993,9 +602,7 @@ public void test1() throws Throwable { } value = msg.biases[14].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[14].bias + "' != '" + 47517353 + "'", - value.equals(BigInteger.valueOf(47517353L))); + org.junit.Assert.assertTrue("'" + msg.biases[14].bias + "' != '" + 47517353 + "'", value.equals(BigInteger.valueOf( 47517353L ) ) ); } else { value = value.longValue(); expected = 47517353L; @@ -1003,9 +610,7 @@ public void test1() throws Throwable { } value = msg.biases[14].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[14].code + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.biases[14].code + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -1013,9 +618,7 @@ public void test1() throws Throwable { } value = msg.biases[14].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[14].discontinuity_counter + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.biases[14].discontinuity_counter + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -1023,9 +626,7 @@ public void test1() throws Throwable { } value = msg.biases[14].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[14].integer_indicator + "' != '" + 175 + "'", - value.equals(BigInteger.valueOf(175L))); + org.junit.Assert.assertTrue("'" + msg.biases[14].integer_indicator + "' != '" + 175 + "'", value.equals(BigInteger.valueOf( 175L ) ) ); } else { value = value.longValue(); expected = 175L; @@ -1033,9 +634,7 @@ public void test1() throws Throwable { } value = msg.biases[14].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[14].widelane_integer_indicator + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.biases[14].widelane_integer_indicator + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -1043,9 +642,7 @@ public void test1() throws Throwable { } value = msg.biases[15].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[15].bias + "' != '" + -2124125745 + "'", - value.equals(BigInteger.valueOf(-2124125745L))); + org.junit.Assert.assertTrue("'" + msg.biases[15].bias + "' != '" + -2124125745 + "'", value.equals(BigInteger.valueOf( -2124125745L ) ) ); } else { value = value.longValue(); expected = -2124125745L; @@ -1053,9 +650,7 @@ public void test1() throws Throwable { } value = msg.biases[15].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[15].code + "' != '" + 197 + "'", - value.equals(BigInteger.valueOf(197L))); + org.junit.Assert.assertTrue("'" + msg.biases[15].code + "' != '" + 197 + "'", value.equals(BigInteger.valueOf( 197L ) ) ); } else { value = value.longValue(); expected = 197L; @@ -1063,9 +658,7 @@ public void test1() throws Throwable { } value = msg.biases[15].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[15].discontinuity_counter + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.biases[15].discontinuity_counter + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -1073,9 +666,7 @@ public void test1() throws Throwable { } value = msg.biases[15].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[15].integer_indicator + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.biases[15].integer_indicator + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -1083,9 +674,7 @@ public void test1() throws Throwable { } value = msg.biases[15].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[15].widelane_integer_indicator + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.biases[15].widelane_integer_indicator + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -1093,9 +682,7 @@ public void test1() throws Throwable { } value = msg.biases[16].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[16].bias + "' != '" + -1401812607 + "'", - value.equals(BigInteger.valueOf(-1401812607L))); + org.junit.Assert.assertTrue("'" + msg.biases[16].bias + "' != '" + -1401812607 + "'", value.equals(BigInteger.valueOf( -1401812607L ) ) ); } else { value = value.longValue(); expected = -1401812607L; @@ -1103,9 +690,7 @@ public void test1() throws Throwable { } value = msg.biases[16].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[16].code + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.biases[16].code + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -1113,9 +698,7 @@ public void test1() throws Throwable { } value = msg.biases[16].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[16].discontinuity_counter + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.biases[16].discontinuity_counter + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -1123,9 +706,7 @@ public void test1() throws Throwable { } value = msg.biases[16].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[16].integer_indicator + "' != '" + 136 + "'", - value.equals(BigInteger.valueOf(136L))); + org.junit.Assert.assertTrue("'" + msg.biases[16].integer_indicator + "' != '" + 136 + "'", value.equals(BigInteger.valueOf( 136L ) ) ); } else { value = value.longValue(); expected = 136L; @@ -1133,9 +714,7 @@ public void test1() throws Throwable { } value = msg.biases[16].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[16].widelane_integer_indicator + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.biases[16].widelane_integer_indicator + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -1143,9 +722,7 @@ public void test1() throws Throwable { } value = msg.biases[17].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[17].bias + "' != '" + 60257151 + "'", - value.equals(BigInteger.valueOf(60257151L))); + org.junit.Assert.assertTrue("'" + msg.biases[17].bias + "' != '" + 60257151 + "'", value.equals(BigInteger.valueOf( 60257151L ) ) ); } else { value = value.longValue(); expected = 60257151L; @@ -1153,9 +730,7 @@ public void test1() throws Throwable { } value = msg.biases[17].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[17].code + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.biases[17].code + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -1163,9 +738,7 @@ public void test1() throws Throwable { } value = msg.biases[17].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[17].discontinuity_counter + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.biases[17].discontinuity_counter + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -1173,9 +746,7 @@ public void test1() throws Throwable { } value = msg.biases[17].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[17].integer_indicator + "' != '" + 150 + "'", - value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.biases[17].integer_indicator + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -1183,9 +754,7 @@ public void test1() throws Throwable { } value = msg.biases[17].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[17].widelane_integer_indicator + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.biases[17].widelane_integer_indicator + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -1193,9 +762,7 @@ public void test1() throws Throwable { } value = msg.biases[18].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[18].bias + "' != '" + 41820677 + "'", - value.equals(BigInteger.valueOf(41820677L))); + org.junit.Assert.assertTrue("'" + msg.biases[18].bias + "' != '" + 41820677 + "'", value.equals(BigInteger.valueOf( 41820677L ) ) ); } else { value = value.longValue(); expected = 41820677L; @@ -1203,9 +770,7 @@ public void test1() throws Throwable { } value = msg.biases[18].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[18].code + "' != '" + 242 + "'", - value.equals(BigInteger.valueOf(242L))); + org.junit.Assert.assertTrue("'" + msg.biases[18].code + "' != '" + 242 + "'", value.equals(BigInteger.valueOf( 242L ) ) ); } else { value = value.longValue(); expected = 242L; @@ -1213,9 +778,7 @@ public void test1() throws Throwable { } value = msg.biases[18].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[18].discontinuity_counter + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.biases[18].discontinuity_counter + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -1223,9 +786,7 @@ public void test1() throws Throwable { } value = msg.biases[18].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[18].integer_indicator + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.biases[18].integer_indicator + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -1233,9 +794,7 @@ public void test1() throws Throwable { } value = msg.biases[18].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[18].widelane_integer_indicator + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.biases[18].widelane_integer_indicator + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -1243,9 +802,7 @@ public void test1() throws Throwable { } value = msg.biases[19].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[19].bias + "' != '" + 1640616471 + "'", - value.equals(BigInteger.valueOf(1640616471L))); + org.junit.Assert.assertTrue("'" + msg.biases[19].bias + "' != '" + 1640616471 + "'", value.equals(BigInteger.valueOf( 1640616471L ) ) ); } else { value = value.longValue(); expected = 1640616471L; @@ -1253,9 +810,7 @@ public void test1() throws Throwable { } value = msg.biases[19].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[19].code + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.biases[19].code + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -1263,9 +818,7 @@ public void test1() throws Throwable { } value = msg.biases[19].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[19].discontinuity_counter + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.biases[19].discontinuity_counter + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -1273,9 +826,7 @@ public void test1() throws Throwable { } value = msg.biases[19].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[19].integer_indicator + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.biases[19].integer_indicator + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -1283,9 +834,7 @@ public void test1() throws Throwable { } value = msg.biases[19].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[19].widelane_integer_indicator + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.biases[19].widelane_integer_indicator + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -1293,9 +842,7 @@ public void test1() throws Throwable { } value = msg.biases[20].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[20].bias + "' != '" + -744786918 + "'", - value.equals(BigInteger.valueOf(-744786918L))); + org.junit.Assert.assertTrue("'" + msg.biases[20].bias + "' != '" + -744786918 + "'", value.equals(BigInteger.valueOf( -744786918L ) ) ); } else { value = value.longValue(); expected = -744786918L; @@ -1303,9 +850,7 @@ public void test1() throws Throwable { } value = msg.biases[20].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[20].code + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.biases[20].code + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -1313,9 +858,7 @@ public void test1() throws Throwable { } value = msg.biases[20].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[20].discontinuity_counter + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.biases[20].discontinuity_counter + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -1323,9 +866,7 @@ public void test1() throws Throwable { } value = msg.biases[20].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[20].integer_indicator + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.biases[20].integer_indicator + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -1333,9 +874,7 @@ public void test1() throws Throwable { } value = msg.biases[20].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[20].widelane_integer_indicator + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.biases[20].widelane_integer_indicator + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -1343,9 +882,7 @@ public void test1() throws Throwable { } value = msg.biases[21].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[21].bias + "' != '" + 1966589763 + "'", - value.equals(BigInteger.valueOf(1966589763L))); + org.junit.Assert.assertTrue("'" + msg.biases[21].bias + "' != '" + 1966589763 + "'", value.equals(BigInteger.valueOf( 1966589763L ) ) ); } else { value = value.longValue(); expected = 1966589763L; @@ -1353,9 +890,7 @@ public void test1() throws Throwable { } value = msg.biases[21].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[21].code + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.biases[21].code + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -1363,9 +898,7 @@ public void test1() throws Throwable { } value = msg.biases[21].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[21].discontinuity_counter + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.biases[21].discontinuity_counter + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -1373,9 +906,7 @@ public void test1() throws Throwable { } value = msg.biases[21].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[21].integer_indicator + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.biases[21].integer_indicator + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -1383,9 +914,7 @@ public void test1() throws Throwable { } value = msg.biases[21].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[21].widelane_integer_indicator + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.biases[21].widelane_integer_indicator + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -1393,9 +922,7 @@ public void test1() throws Throwable { } value = msg.biases[22].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[22].bias + "' != '" + 364366310 + "'", - value.equals(BigInteger.valueOf(364366310L))); + org.junit.Assert.assertTrue("'" + msg.biases[22].bias + "' != '" + 364366310 + "'", value.equals(BigInteger.valueOf( 364366310L ) ) ); } else { value = value.longValue(); expected = 364366310L; @@ -1403,9 +930,7 @@ public void test1() throws Throwable { } value = msg.biases[22].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[22].code + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.biases[22].code + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -1413,9 +938,7 @@ public void test1() throws Throwable { } value = msg.biases[22].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[22].discontinuity_counter + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.biases[22].discontinuity_counter + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1423,9 +946,7 @@ public void test1() throws Throwable { } value = msg.biases[22].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[22].integer_indicator + "' != '" + 169 + "'", - value.equals(BigInteger.valueOf(169L))); + org.junit.Assert.assertTrue("'" + msg.biases[22].integer_indicator + "' != '" + 169 + "'", value.equals(BigInteger.valueOf( 169L ) ) ); } else { value = value.longValue(); expected = 169L; @@ -1433,9 +954,7 @@ public void test1() throws Throwable { } value = msg.biases[22].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[22].widelane_integer_indicator + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.biases[22].widelane_integer_indicator + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -1443,9 +962,7 @@ public void test1() throws Throwable { } value = msg.biases[23].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[23].bias + "' != '" + -1839031379 + "'", - value.equals(BigInteger.valueOf(-1839031379L))); + org.junit.Assert.assertTrue("'" + msg.biases[23].bias + "' != '" + -1839031379 + "'", value.equals(BigInteger.valueOf( -1839031379L ) ) ); } else { value = value.longValue(); expected = -1839031379L; @@ -1453,9 +970,7 @@ public void test1() throws Throwable { } value = msg.biases[23].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[23].code + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.biases[23].code + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -1463,9 +978,7 @@ public void test1() throws Throwable { } value = msg.biases[23].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[23].discontinuity_counter + "' != '" + 173 + "'", - value.equals(BigInteger.valueOf(173L))); + org.junit.Assert.assertTrue("'" + msg.biases[23].discontinuity_counter + "' != '" + 173 + "'", value.equals(BigInteger.valueOf( 173L ) ) ); } else { value = value.longValue(); expected = 173L; @@ -1473,9 +986,7 @@ public void test1() throws Throwable { } value = msg.biases[23].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[23].integer_indicator + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.biases[23].integer_indicator + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -1483,9 +994,7 @@ public void test1() throws Throwable { } value = msg.biases[23].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[23].widelane_integer_indicator + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.biases[23].widelane_integer_indicator + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -1493,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.biases[24].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[24].bias + "' != '" + 31817639 + "'", - value.equals(BigInteger.valueOf(31817639L))); + org.junit.Assert.assertTrue("'" + msg.biases[24].bias + "' != '" + 31817639 + "'", value.equals(BigInteger.valueOf( 31817639L ) ) ); } else { value = value.longValue(); expected = 31817639L; @@ -1503,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.biases[24].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[24].code + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.biases[24].code + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -1513,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.biases[24].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[24].discontinuity_counter + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.biases[24].discontinuity_counter + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -1523,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.biases[24].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[24].integer_indicator + "' != '" + 167 + "'", - value.equals(BigInteger.valueOf(167L))); + org.junit.Assert.assertTrue("'" + msg.biases[24].integer_indicator + "' != '" + 167 + "'", value.equals(BigInteger.valueOf( 167L ) ) ); } else { value = value.longValue(); expected = 167L; @@ -1533,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.biases[24].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[24].widelane_integer_indicator + "' != '" + 138 + "'", - value.equals(BigInteger.valueOf(138L))); + org.junit.Assert.assertTrue("'" + msg.biases[24].widelane_integer_indicator + "' != '" + 138 + "'", value.equals(BigInteger.valueOf( 138L ) ) ); } else { value = value.longValue(); expected = 138L; @@ -1543,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.biases[25].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[25].bias + "' != '" + -1619830156 + "'", - value.equals(BigInteger.valueOf(-1619830156L))); + org.junit.Assert.assertTrue("'" + msg.biases[25].bias + "' != '" + -1619830156 + "'", value.equals(BigInteger.valueOf( -1619830156L ) ) ); } else { value = value.longValue(); expected = -1619830156L; @@ -1553,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.biases[25].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[25].code + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.biases[25].code + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1563,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.biases[25].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[25].discontinuity_counter + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.biases[25].discontinuity_counter + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -1573,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.biases[25].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[25].integer_indicator + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.biases[25].integer_indicator + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -1583,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.biases[25].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[25].widelane_integer_indicator + "' != '" + 237 + "'", - value.equals(BigInteger.valueOf(237L))); + org.junit.Assert.assertTrue("'" + msg.biases[25].widelane_integer_indicator + "' != '" + 237 + "'", value.equals(BigInteger.valueOf( 237L ) ) ); } else { value = value.longValue(); expected = 237L; @@ -1593,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.biases[26].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[26].bias + "' != '" + -83375622 + "'", - value.equals(BigInteger.valueOf(-83375622L))); + org.junit.Assert.assertTrue("'" + msg.biases[26].bias + "' != '" + -83375622 + "'", value.equals(BigInteger.valueOf( -83375622L ) ) ); } else { value = value.longValue(); expected = -83375622L; @@ -1603,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.biases[26].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[26].code + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.biases[26].code + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1613,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.biases[26].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[26].discontinuity_counter + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.biases[26].discontinuity_counter + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -1623,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.biases[26].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[26].integer_indicator + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.biases[26].integer_indicator + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -1633,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.biases[26].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[26].widelane_integer_indicator + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.biases[26].widelane_integer_indicator + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -1643,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.biases[27].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[27].bias + "' != '" + 1077458389 + "'", - value.equals(BigInteger.valueOf(1077458389L))); + org.junit.Assert.assertTrue("'" + msg.biases[27].bias + "' != '" + 1077458389 + "'", value.equals(BigInteger.valueOf( 1077458389L ) ) ); } else { value = value.longValue(); expected = 1077458389L; @@ -1653,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.biases[27].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[27].code + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.biases[27].code + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1663,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.biases[27].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[27].discontinuity_counter + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.biases[27].discontinuity_counter + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -1673,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.biases[27].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[27].integer_indicator + "' != '" + 75 + "'", - value.equals(BigInteger.valueOf(75L))); + org.junit.Assert.assertTrue("'" + msg.biases[27].integer_indicator + "' != '" + 75 + "'", value.equals(BigInteger.valueOf( 75L ) ) ); } else { value = value.longValue(); expected = 75L; @@ -1683,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.biases[27].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[27].widelane_integer_indicator + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.biases[27].widelane_integer_indicator + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1693,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.biases[28].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[28].bias + "' != '" + -883355501 + "'", - value.equals(BigInteger.valueOf(-883355501L))); + org.junit.Assert.assertTrue("'" + msg.biases[28].bias + "' != '" + -883355501 + "'", value.equals(BigInteger.valueOf( -883355501L ) ) ); } else { value = value.longValue(); expected = -883355501L; @@ -1703,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.biases[28].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[28].code + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.biases[28].code + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -1713,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.biases[28].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[28].discontinuity_counter + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.biases[28].discontinuity_counter + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1723,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.biases[28].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[28].integer_indicator + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.biases[28].integer_indicator + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -1733,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.biases[28].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[28].widelane_integer_indicator + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.biases[28].widelane_integer_indicator + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -1743,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.biases[29].bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[29].bias + "' != '" + -1448611273 + "'", - value.equals(BigInteger.valueOf(-1448611273L))); + org.junit.Assert.assertTrue("'" + msg.biases[29].bias + "' != '" + -1448611273 + "'", value.equals(BigInteger.valueOf( -1448611273L ) ) ); } else { value = value.longValue(); expected = -1448611273L; @@ -1753,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.biases[29].code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[29].code + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.biases[29].code + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -1763,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.biases[29].discontinuity_counter; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[29].discontinuity_counter + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.biases[29].discontinuity_counter + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1773,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.biases[29].integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[29].integer_indicator + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.biases[29].integer_indicator + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -1783,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.biases[29].widelane_integer_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.biases[29].widelane_integer_indicator + "' != '" + 243 + "'", - value.equals(BigInteger.valueOf(243L))); + org.junit.Assert.assertTrue("'" + msg.biases[29].widelane_integer_indicator + "' != '" + 243 + "'", value.equals(BigInteger.valueOf( 243L ) ) ); } else { value = value.longValue(); expected = 243L; @@ -1793,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.dispersive_bias; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.dispersive_bias + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.dispersive_bias + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -1803,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.iod_ssr; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.iod_ssr + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.iod_ssr + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1813,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.mw_consistency; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.mw_consistency + "' != '" + 209 + "'", - value.equals(BigInteger.valueOf(209L))); + org.junit.Assert.assertTrue("'" + msg.mw_consistency + "' != '" + 209 + "'", value.equals(BigInteger.valueOf( 209L ) ) ); } else { value = value.longValue(); expected = 209L; @@ -1823,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -1833,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 169 + "'", - value.equals(BigInteger.valueOf(169L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 169 + "'", value.equals(BigInteger.valueOf( 169L ) ) ); } else { value = value.longValue(); expected = 169L; @@ -1843,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time.tow + "' != '" + 210803409 + "'", - value.equals(BigInteger.valueOf(210803409L))); + org.junit.Assert.assertTrue("'" + msg.time.tow + "' != '" + 210803409 + "'", value.equals(BigInteger.valueOf( 210803409L ) ) ); } else { value = value.longValue(); expected = 210803409L; @@ -1853,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time.wn + "' != '" + 42197 + "'", - value.equals(BigInteger.valueOf(42197L))); + org.junit.Assert.assertTrue("'" + msg.time.wn + "' != '" + 42197 + "'", value.equals(BigInteger.valueOf( 42197L ) ) ); } else { value = value.longValue(); expected = 42197L; @@ -1863,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.update_interval + "' != '" + 177 + "'", - value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.update_interval + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -1873,8 +1306,7 @@ public void test1() throws Throwable { } value = msg.yaw; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.yaw + "' != '" + 5881 + "'", value.equals(BigInteger.valueOf(5881L))); + org.junit.Assert.assertTrue("'" + msg.yaw + "' != '" + 5881 + "'", value.equals(BigInteger.valueOf( 5881L ) ) ); } else { value = value.longValue(); expected = 5881L; @@ -1882,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.yaw_rate; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.yaw_rate + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.yaw_rate + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrSatelliteApcDepATest.java b/java/test/auto_check_sbp_ssr_MsgSsrSatelliteApcDepATest.java index c5253edc1..7d60b96d7 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrSatelliteApcDepATest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrSatelliteApcDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrSatelliteApcDepA.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrSatelliteApcDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrSatelliteApcDep; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrSatelliteApcDepATest { @@ -30,243 +34,15 @@ public class auto_check_sbp_ssr_MsgSsrSatelliteApcDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrSatelliteApcDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 203, - (byte) 169, - (byte) 240, - (byte) 78, - (byte) 4, - (byte) 213, - (byte) 171, - (byte) 254, - (byte) 214, - (byte) 212, - (byte) 4, - (byte) 8, - (byte) 33, - (byte) 31, - (byte) 80, - (byte) 21, - (byte) 4, - (byte) 105, - (byte) 225, - (byte) 39, - (byte) 139, - (byte) 124, - (byte) 149, - (byte) 48, - (byte) 15, - (byte) 214, - (byte) 197, - (byte) 141, - (byte) 32, - (byte) 33, - (byte) 135, - (byte) 150, - (byte) 148, - (byte) 123, - (byte) 49, - (byte) 135, - (byte) 97, - (byte) 39, - (byte) 90, - (byte) 20, - (byte) 169, - (byte) 239, - (byte) 47, - (byte) 153, - (byte) 175, - (byte) 35, - (byte) 145, - (byte) 145, - (byte) 123, - (byte) 194, - (byte) 2, - (byte) 102, - (byte) 74, - (byte) 149, - (byte) 95, - (byte) 171, - (byte) 238, - (byte) 249, - (byte) 7, - (byte) 237, - (byte) 170, - (byte) 125, - (byte) 106, - (byte) 158, - (byte) 83, - (byte) 188, - (byte) 181, - (byte) 194, - (byte) 27, - (byte) 84, - (byte) 226, - (byte) 142, - (byte) 123, - (byte) 77, - (byte) 217, - (byte) 248, - (byte) 67, - (byte) 215, - (byte) 129, - (byte) 114, - (byte) 138, - (byte) 25, - (byte) 240, - (byte) 10, - (byte) 56, - (byte) 76, - (byte) 61, - (byte) 161, - (byte) 216, - (byte) 22, - (byte) 181, - (byte) 174, - (byte) 33, - (byte) 13, - (byte) 252, - (byte) 236, - (byte) 230, - (byte) 196, - (byte) 128, - (byte) 215, - (byte) 239, - (byte) 234, - (byte) 179, - (byte) 220, - (byte) 44, - (byte) 212, - (byte) 57, - (byte) 44, - (byte) 173, - (byte) 49, - (byte) 36, - (byte) 137, - (byte) 248, - (byte) 235, - (byte) 97, - (byte) 112, - (byte) 157, - (byte) 139, - (byte) 26, - (byte) 115, - (byte) 192, - (byte) 31, - (byte) 85, - (byte) 127, - (byte) 228, - (byte) 81, - (byte) 252, - (byte) 219, - (byte) 249, - (byte) 110, - (byte) 147, - (byte) 8, - (byte) 161, - (byte) 215, - (byte) 212, - (byte) 180, - (byte) 25, - (byte) 83, - (byte) 144, - (byte) 247, - (byte) 12, - (byte) 27, - (byte) 199, - (byte) 173, - (byte) 74, - (byte) 23, - (byte) 4, - (byte) 239, - (byte) 103, - (byte) 223, - (byte) 220, - (byte) 139, - (byte) 91, - (byte) 127, - (byte) 214, - (byte) 86, - (byte) 48, - (byte) 203, - (byte) 228, - (byte) 99, - (byte) 45, - (byte) 83, - (byte) 159, - (byte) 11, - (byte) 250, - (byte) 135, - (byte) 170, - (byte) 42, - (byte) 217, - (byte) 199, - (byte) 233, - (byte) 42, - (byte) 170, - (byte) 78, - (byte) 206, - (byte) 41, - (byte) 43, - (byte) 81, - (byte) 247, - (byte) 99, - (byte) 198, - (byte) 144, - (byte) 2, - (byte) 132, - (byte) 2, - (byte) 224, - (byte) 220, - (byte) 148, - (byte) 58, - (byte) 85, - (byte) 138, - (byte) 210, - (byte) 200, - (byte) 158, - (byte) 7, - (byte) 158, - (byte) 67, - (byte) 46, - (byte) 200, - (byte) 132, - (byte) 118, - (byte) 241, - (byte) 13, - (byte) 37, - (byte) 62, - (byte) 107, - (byte) 253, - (byte) 190, - (byte) 136, - (byte) 66, - (byte) 9, - (byte) 84, - (byte) 155, - (byte) 86, - (byte) 180, - (byte) 41, - (byte) 196, - (byte) 40, - (byte) 119, - (byte) 101, - (byte) 252, - (byte) 223, - (byte) 144, - (byte) 153, - }; - SBPMessage sbp = new SBPMessage(0x1338, 0x604, payload); - MsgSsrSatelliteApcDep msg = new MsgSsrSatelliteApcDep(sbp); + byte[] payload = new byte[] {(byte)203,(byte)169,(byte)240,(byte)78,(byte)4,(byte)213,(byte)171,(byte)254,(byte)214,(byte)212,(byte)4,(byte)8,(byte)33,(byte)31,(byte)80,(byte)21,(byte)4,(byte)105,(byte)225,(byte)39,(byte)139,(byte)124,(byte)149,(byte)48,(byte)15,(byte)214,(byte)197,(byte)141,(byte)32,(byte)33,(byte)135,(byte)150,(byte)148,(byte)123,(byte)49,(byte)135,(byte)97,(byte)39,(byte)90,(byte)20,(byte)169,(byte)239,(byte)47,(byte)153,(byte)175,(byte)35,(byte)145,(byte)145,(byte)123,(byte)194,(byte)2,(byte)102,(byte)74,(byte)149,(byte)95,(byte)171,(byte)238,(byte)249,(byte)7,(byte)237,(byte)170,(byte)125,(byte)106,(byte)158,(byte)83,(byte)188,(byte)181,(byte)194,(byte)27,(byte)84,(byte)226,(byte)142,(byte)123,(byte)77,(byte)217,(byte)248,(byte)67,(byte)215,(byte)129,(byte)114,(byte)138,(byte)25,(byte)240,(byte)10,(byte)56,(byte)76,(byte)61,(byte)161,(byte)216,(byte)22,(byte)181,(byte)174,(byte)33,(byte)13,(byte)252,(byte)236,(byte)230,(byte)196,(byte)128,(byte)215,(byte)239,(byte)234,(byte)179,(byte)220,(byte)44,(byte)212,(byte)57,(byte)44,(byte)173,(byte)49,(byte)36,(byte)137,(byte)248,(byte)235,(byte)97,(byte)112,(byte)157,(byte)139,(byte)26,(byte)115,(byte)192,(byte)31,(byte)85,(byte)127,(byte)228,(byte)81,(byte)252,(byte)219,(byte)249,(byte)110,(byte)147,(byte)8,(byte)161,(byte)215,(byte)212,(byte)180,(byte)25,(byte)83,(byte)144,(byte)247,(byte)12,(byte)27,(byte)199,(byte)173,(byte)74,(byte)23,(byte)4,(byte)239,(byte)103,(byte)223,(byte)220,(byte)139,(byte)91,(byte)127,(byte)214,(byte)86,(byte)48,(byte)203,(byte)228,(byte)99,(byte)45,(byte)83,(byte)159,(byte)11,(byte)250,(byte)135,(byte)170,(byte)42,(byte)217,(byte)199,(byte)233,(byte)42,(byte)170,(byte)78,(byte)206,(byte)41,(byte)43,(byte)81,(byte)247,(byte)99,(byte)198,(byte)144,(byte)2,(byte)132,(byte)2,(byte)224,(byte)220,(byte)148,(byte)58,(byte)85,(byte)138,(byte)210,(byte)200,(byte)158,(byte)7,(byte)158,(byte)67,(byte)46,(byte)200,(byte)132,(byte)118,(byte)241,(byte)13,(byte)37,(byte)62,(byte)107,(byte)253,(byte)190,(byte)136,(byte)66,(byte)9,(byte)84,(byte)155,(byte)86,(byte)180,(byte)41,(byte)196,(byte)40,(byte)119,(byte)101,(byte)252,(byte)223,(byte)144,(byte)153, }; + SBPMessage sbp = new SBPMessage( 0x1338, 0x604, payload ); + MsgSsrSatelliteApcDep msg = new MsgSsrSatelliteApcDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.apc[0].pco[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pco[0] + "' != '" + -21547 + "'", - value.equals(BigInteger.valueOf(-21547L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pco[0] + "' != '" + -21547 + "'", value.equals(BigInteger.valueOf( -21547L ) ) ); } else { value = value.longValue(); expected = -21547L; @@ -274,9 +50,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pco[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pco[1] + "' != '" + -10498 + "'", - value.equals(BigInteger.valueOf(-10498L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pco[1] + "' != '" + -10498 + "'", value.equals(BigInteger.valueOf( -10498L ) ) ); } else { value = value.longValue(); expected = -10498L; @@ -284,9 +58,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pco[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pco[2] + "' != '" + 1236 + "'", - value.equals(BigInteger.valueOf(1236L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pco[2] + "' != '" + 1236 + "'", value.equals(BigInteger.valueOf( 1236L ) ) ); } else { value = value.longValue(); expected = 1236L; @@ -294,9 +66,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[0] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[0] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -304,9 +74,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[1] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[1] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -314,9 +82,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[2] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[2] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -324,9 +90,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[3] + "' != '" + 80 + "'", - value.equals(BigInteger.valueOf(80L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[3] + "' != '" + 80 + "'", value.equals(BigInteger.valueOf( 80L ) ) ); } else { value = value.longValue(); expected = 80L; @@ -334,9 +98,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[4] + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[4] + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -344,9 +106,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[5] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[5] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -354,9 +114,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[6] + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[6] + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -364,9 +122,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[7] + "' != '" + -31 + "'", - value.equals(BigInteger.valueOf(-31L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[7] + "' != '" + -31 + "'", value.equals(BigInteger.valueOf( -31L ) ) ); } else { value = value.longValue(); expected = -31L; @@ -374,9 +130,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[8] + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[8] + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -384,9 +138,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[9] + "' != '" + -117 + "'", - value.equals(BigInteger.valueOf(-117L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[9] + "' != '" + -117 + "'", value.equals(BigInteger.valueOf( -117L ) ) ); } else { value = value.longValue(); expected = -117L; @@ -394,9 +146,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[10] + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[10] + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -404,9 +154,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[11] + "' != '" + -107 + "'", - value.equals(BigInteger.valueOf(-107L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[11] + "' != '" + -107 + "'", value.equals(BigInteger.valueOf( -107L ) ) ); } else { value = value.longValue(); expected = -107L; @@ -414,9 +162,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[12] + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[12] + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -424,9 +170,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[13] + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[13] + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -434,9 +178,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[14] + "' != '" + -42 + "'", - value.equals(BigInteger.valueOf(-42L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[14] + "' != '" + -42 + "'", value.equals(BigInteger.valueOf( -42L ) ) ); } else { value = value.longValue(); expected = -42L; @@ -444,9 +186,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[15] + "' != '" + -59 + "'", - value.equals(BigInteger.valueOf(-59L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[15] + "' != '" + -59 + "'", value.equals(BigInteger.valueOf( -59L ) ) ); } else { value = value.longValue(); expected = -59L; @@ -454,9 +194,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[16] + "' != '" + -115 + "'", - value.equals(BigInteger.valueOf(-115L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[16] + "' != '" + -115 + "'", value.equals(BigInteger.valueOf( -115L ) ) ); } else { value = value.longValue(); expected = -115L; @@ -464,9 +202,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[17] + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[17] + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -474,9 +210,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[18] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[18] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -484,9 +218,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[19] + "' != '" + -121 + "'", - value.equals(BigInteger.valueOf(-121L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[19] + "' != '" + -121 + "'", value.equals(BigInteger.valueOf( -121L ) ) ); } else { value = value.longValue(); expected = -121L; @@ -494,9 +226,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[20] + "' != '" + -106 + "'", - value.equals(BigInteger.valueOf(-106L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[20] + "' != '" + -106 + "'", value.equals(BigInteger.valueOf( -106L ) ) ); } else { value = value.longValue(); expected = -106L; @@ -504,9 +234,7 @@ public void test1() throws Throwable { } value = msg.apc[0].sat_info; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].sat_info + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].sat_info + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -514,9 +242,7 @@ public void test1() throws Throwable { } value = msg.apc[0].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].sid.code + "' != '" + 169 + "'", - value.equals(BigInteger.valueOf(169L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].sid.code + "' != '" + 169 + "'", value.equals(BigInteger.valueOf( 169L ) ) ); } else { value = value.longValue(); expected = 169L; @@ -524,9 +250,7 @@ public void test1() throws Throwable { } value = msg.apc[0].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].sid.sat + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].sid.sat + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -534,9 +258,7 @@ public void test1() throws Throwable { } value = msg.apc[0].svn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].svn + "' != '" + 1102 + "'", - value.equals(BigInteger.valueOf(1102L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].svn + "' != '" + 1102 + "'", value.equals(BigInteger.valueOf( 1102L ) ) ); } else { value = value.longValue(); expected = 1102L; @@ -544,9 +266,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pco[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pco[0] + "' != '" + 23079 + "'", - value.equals(BigInteger.valueOf(23079L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pco[0] + "' != '" + 23079 + "'", value.equals(BigInteger.valueOf( 23079L ) ) ); } else { value = value.longValue(); expected = 23079L; @@ -554,9 +274,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pco[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pco[1] + "' != '" + -22252 + "'", - value.equals(BigInteger.valueOf(-22252L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pco[1] + "' != '" + -22252 + "'", value.equals(BigInteger.valueOf( -22252L ) ) ); } else { value = value.longValue(); expected = -22252L; @@ -564,9 +282,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pco[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pco[2] + "' != '" + 12271 + "'", - value.equals(BigInteger.valueOf(12271L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pco[2] + "' != '" + 12271 + "'", value.equals(BigInteger.valueOf( 12271L ) ) ); } else { value = value.longValue(); expected = 12271L; @@ -574,9 +290,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[0] + "' != '" + -103 + "'", - value.equals(BigInteger.valueOf(-103L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[0] + "' != '" + -103 + "'", value.equals(BigInteger.valueOf( -103L ) ) ); } else { value = value.longValue(); expected = -103L; @@ -584,9 +298,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[1] + "' != '" + -81 + "'", - value.equals(BigInteger.valueOf(-81L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[1] + "' != '" + -81 + "'", value.equals(BigInteger.valueOf( -81L ) ) ); } else { value = value.longValue(); expected = -81L; @@ -594,9 +306,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[2] + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[2] + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -604,9 +314,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[3] + "' != '" + -111 + "'", - value.equals(BigInteger.valueOf(-111L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[3] + "' != '" + -111 + "'", value.equals(BigInteger.valueOf( -111L ) ) ); } else { value = value.longValue(); expected = -111L; @@ -614,9 +322,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[4] + "' != '" + -111 + "'", - value.equals(BigInteger.valueOf(-111L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[4] + "' != '" + -111 + "'", value.equals(BigInteger.valueOf( -111L ) ) ); } else { value = value.longValue(); expected = -111L; @@ -624,9 +330,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[5] + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[5] + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -634,9 +338,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[6] + "' != '" + -62 + "'", - value.equals(BigInteger.valueOf(-62L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[6] + "' != '" + -62 + "'", value.equals(BigInteger.valueOf( -62L ) ) ); } else { value = value.longValue(); expected = -62L; @@ -644,9 +346,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[7] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[7] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -654,9 +354,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[8] + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[8] + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -664,9 +362,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[9] + "' != '" + 74 + "'", - value.equals(BigInteger.valueOf(74L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[9] + "' != '" + 74 + "'", value.equals(BigInteger.valueOf( 74L ) ) ); } else { value = value.longValue(); expected = 74L; @@ -674,9 +370,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[10] + "' != '" + -107 + "'", - value.equals(BigInteger.valueOf(-107L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[10] + "' != '" + -107 + "'", value.equals(BigInteger.valueOf( -107L ) ) ); } else { value = value.longValue(); expected = -107L; @@ -684,9 +378,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[11] + "' != '" + 95 + "'", - value.equals(BigInteger.valueOf(95L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[11] + "' != '" + 95 + "'", value.equals(BigInteger.valueOf( 95L ) ) ); } else { value = value.longValue(); expected = 95L; @@ -694,9 +386,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[12] + "' != '" + -85 + "'", - value.equals(BigInteger.valueOf(-85L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[12] + "' != '" + -85 + "'", value.equals(BigInteger.valueOf( -85L ) ) ); } else { value = value.longValue(); expected = -85L; @@ -704,9 +394,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[13] + "' != '" + -18 + "'", - value.equals(BigInteger.valueOf(-18L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[13] + "' != '" + -18 + "'", value.equals(BigInteger.valueOf( -18L ) ) ); } else { value = value.longValue(); expected = -18L; @@ -714,9 +402,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[14] + "' != '" + -7 + "'", - value.equals(BigInteger.valueOf(-7L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[14] + "' != '" + -7 + "'", value.equals(BigInteger.valueOf( -7L ) ) ); } else { value = value.longValue(); expected = -7L; @@ -724,9 +410,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[15] + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[15] + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -734,9 +418,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[16] + "' != '" + -19 + "'", - value.equals(BigInteger.valueOf(-19L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[16] + "' != '" + -19 + "'", value.equals(BigInteger.valueOf( -19L ) ) ); } else { value = value.longValue(); expected = -19L; @@ -744,9 +426,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[17] + "' != '" + -86 + "'", - value.equals(BigInteger.valueOf(-86L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[17] + "' != '" + -86 + "'", value.equals(BigInteger.valueOf( -86L ) ) ); } else { value = value.longValue(); expected = -86L; @@ -754,9 +434,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[18] + "' != '" + 125 + "'", - value.equals(BigInteger.valueOf(125L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[18] + "' != '" + 125 + "'", value.equals(BigInteger.valueOf( 125L ) ) ); } else { value = value.longValue(); expected = 125L; @@ -764,9 +442,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[19] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[19] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -774,9 +450,7 @@ public void test1() throws Throwable { } value = msg.apc[1].pcv[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].pcv[20] + "' != '" + -98 + "'", - value.equals(BigInteger.valueOf(-98L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].pcv[20] + "' != '" + -98 + "'", value.equals(BigInteger.valueOf( -98L ) ) ); } else { value = value.longValue(); expected = -98L; @@ -784,9 +458,7 @@ public void test1() throws Throwable { } value = msg.apc[1].sat_info; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].sat_info + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].sat_info + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -794,9 +466,7 @@ public void test1() throws Throwable { } value = msg.apc[1].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].sid.code + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].sid.code + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -804,9 +474,7 @@ public void test1() throws Throwable { } value = msg.apc[1].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].sid.sat + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].sid.sat + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -814,9 +482,7 @@ public void test1() throws Throwable { } value = msg.apc[1].svn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[1].svn + "' != '" + 24967 + "'", - value.equals(BigInteger.valueOf(24967L))); + org.junit.Assert.assertTrue("'" + msg.apc[1].svn + "' != '" + 24967 + "'", value.equals(BigInteger.valueOf( 24967L ) ) ); } else { value = value.longValue(); expected = 24967L; @@ -824,9 +490,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pco[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pco[0] + "' != '" + -7596 + "'", - value.equals(BigInteger.valueOf(-7596L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pco[0] + "' != '" + -7596 + "'", value.equals(BigInteger.valueOf( -7596L ) ) ); } else { value = value.longValue(); expected = -7596L; @@ -834,9 +498,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pco[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pco[1] + "' != '" + 31630 + "'", - value.equals(BigInteger.valueOf(31630L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pco[1] + "' != '" + 31630 + "'", value.equals(BigInteger.valueOf( 31630L ) ) ); } else { value = value.longValue(); expected = 31630L; @@ -844,9 +506,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pco[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pco[2] + "' != '" + -9907 + "'", - value.equals(BigInteger.valueOf(-9907L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pco[2] + "' != '" + -9907 + "'", value.equals(BigInteger.valueOf( -9907L ) ) ); } else { value = value.longValue(); expected = -9907L; @@ -854,9 +514,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[0] + "' != '" + -8 + "'", - value.equals(BigInteger.valueOf(-8L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[0] + "' != '" + -8 + "'", value.equals(BigInteger.valueOf( -8L ) ) ); } else { value = value.longValue(); expected = -8L; @@ -864,9 +522,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[1] + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[1] + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -874,9 +530,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[2] + "' != '" + -41 + "'", - value.equals(BigInteger.valueOf(-41L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[2] + "' != '" + -41 + "'", value.equals(BigInteger.valueOf( -41L ) ) ); } else { value = value.longValue(); expected = -41L; @@ -884,9 +538,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[3] + "' != '" + -127 + "'", - value.equals(BigInteger.valueOf(-127L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[3] + "' != '" + -127 + "'", value.equals(BigInteger.valueOf( -127L ) ) ); } else { value = value.longValue(); expected = -127L; @@ -894,9 +546,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[4] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[4] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -904,9 +554,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[5] + "' != '" + -118 + "'", - value.equals(BigInteger.valueOf(-118L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[5] + "' != '" + -118 + "'", value.equals(BigInteger.valueOf( -118L ) ) ); } else { value = value.longValue(); expected = -118L; @@ -914,9 +562,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[6] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[6] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -924,9 +570,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[7] + "' != '" + -16 + "'", - value.equals(BigInteger.valueOf(-16L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[7] + "' != '" + -16 + "'", value.equals(BigInteger.valueOf( -16L ) ) ); } else { value = value.longValue(); expected = -16L; @@ -934,9 +578,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[8] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[8] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -944,9 +586,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[9] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[9] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -954,9 +594,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[10] + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[10] + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -964,9 +602,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[11] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[11] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -974,9 +610,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[12] + "' != '" + -95 + "'", - value.equals(BigInteger.valueOf(-95L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[12] + "' != '" + -95 + "'", value.equals(BigInteger.valueOf( -95L ) ) ); } else { value = value.longValue(); expected = -95L; @@ -984,9 +618,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[13] + "' != '" + -40 + "'", - value.equals(BigInteger.valueOf(-40L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[13] + "' != '" + -40 + "'", value.equals(BigInteger.valueOf( -40L ) ) ); } else { value = value.longValue(); expected = -40L; @@ -994,9 +626,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[14] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[14] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -1004,9 +634,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[15] + "' != '" + -75 + "'", - value.equals(BigInteger.valueOf(-75L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[15] + "' != '" + -75 + "'", value.equals(BigInteger.valueOf( -75L ) ) ); } else { value = value.longValue(); expected = -75L; @@ -1014,9 +642,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[16] + "' != '" + -82 + "'", - value.equals(BigInteger.valueOf(-82L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[16] + "' != '" + -82 + "'", value.equals(BigInteger.valueOf( -82L ) ) ); } else { value = value.longValue(); expected = -82L; @@ -1024,9 +650,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[17] + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[17] + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -1034,9 +658,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[18] + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[18] + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -1044,9 +666,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[19] + "' != '" + -4 + "'", - value.equals(BigInteger.valueOf(-4L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[19] + "' != '" + -4 + "'", value.equals(BigInteger.valueOf( -4L ) ) ); } else { value = value.longValue(); expected = -4L; @@ -1054,9 +674,7 @@ public void test1() throws Throwable { } value = msg.apc[2].pcv[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].pcv[20] + "' != '" + -20 + "'", - value.equals(BigInteger.valueOf(-20L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].pcv[20] + "' != '" + -20 + "'", value.equals(BigInteger.valueOf( -20L ) ) ); } else { value = value.longValue(); expected = -20L; @@ -1064,9 +682,7 @@ public void test1() throws Throwable { } value = msg.apc[2].sat_info; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].sat_info + "' != '" + 181 + "'", - value.equals(BigInteger.valueOf(181L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].sat_info + "' != '" + 181 + "'", value.equals(BigInteger.valueOf( 181L ) ) ); } else { value = value.longValue(); expected = 181L; @@ -1074,9 +690,7 @@ public void test1() throws Throwable { } value = msg.apc[2].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].sid.code + "' != '" + 188 + "'", - value.equals(BigInteger.valueOf(188L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].sid.code + "' != '" + 188 + "'", value.equals(BigInteger.valueOf( 188L ) ) ); } else { value = value.longValue(); expected = 188L; @@ -1084,9 +698,7 @@ public void test1() throws Throwable { } value = msg.apc[2].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].sid.sat + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].sid.sat + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -1094,9 +706,7 @@ public void test1() throws Throwable { } value = msg.apc[2].svn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[2].svn + "' != '" + 7106 + "'", - value.equals(BigInteger.valueOf(7106L))); + org.junit.Assert.assertTrue("'" + msg.apc[2].svn + "' != '" + 7106 + "'", value.equals(BigInteger.valueOf( 7106L ) ) ); } else { value = value.longValue(); expected = 7106L; @@ -1104,9 +714,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pco[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pco[0] + "' != '" + -19478 + "'", - value.equals(BigInteger.valueOf(-19478L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pco[0] + "' != '" + -19478 + "'", value.equals(BigInteger.valueOf( -19478L ) ) ); } else { value = value.longValue(); expected = -19478L; @@ -1114,9 +722,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pco[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pco[1] + "' != '" + 11484 + "'", - value.equals(BigInteger.valueOf(11484L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pco[1] + "' != '" + 11484 + "'", value.equals(BigInteger.valueOf( 11484L ) ) ); } else { value = value.longValue(); expected = 11484L; @@ -1124,9 +730,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pco[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pco[2] + "' != '" + 14804 + "'", - value.equals(BigInteger.valueOf(14804L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pco[2] + "' != '" + 14804 + "'", value.equals(BigInteger.valueOf( 14804L ) ) ); } else { value = value.longValue(); expected = 14804L; @@ -1134,9 +738,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[0] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[0] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -1144,9 +746,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[1] + "' != '" + -83 + "'", - value.equals(BigInteger.valueOf(-83L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[1] + "' != '" + -83 + "'", value.equals(BigInteger.valueOf( -83L ) ) ); } else { value = value.longValue(); expected = -83L; @@ -1154,9 +754,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[2] + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[2] + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -1164,9 +762,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[3] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[3] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -1174,9 +770,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[4] + "' != '" + -119 + "'", - value.equals(BigInteger.valueOf(-119L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[4] + "' != '" + -119 + "'", value.equals(BigInteger.valueOf( -119L ) ) ); } else { value = value.longValue(); expected = -119L; @@ -1184,9 +778,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[5] + "' != '" + -8 + "'", - value.equals(BigInteger.valueOf(-8L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[5] + "' != '" + -8 + "'", value.equals(BigInteger.valueOf( -8L ) ) ); } else { value = value.longValue(); expected = -8L; @@ -1194,9 +786,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[6] + "' != '" + -21 + "'", - value.equals(BigInteger.valueOf(-21L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[6] + "' != '" + -21 + "'", value.equals(BigInteger.valueOf( -21L ) ) ); } else { value = value.longValue(); expected = -21L; @@ -1204,9 +794,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[7] + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[7] + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -1214,9 +802,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[8] + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[8] + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -1224,9 +810,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[9] + "' != '" + -99 + "'", - value.equals(BigInteger.valueOf(-99L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[9] + "' != '" + -99 + "'", value.equals(BigInteger.valueOf( -99L ) ) ); } else { value = value.longValue(); expected = -99L; @@ -1234,9 +818,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[10] + "' != '" + -117 + "'", - value.equals(BigInteger.valueOf(-117L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[10] + "' != '" + -117 + "'", value.equals(BigInteger.valueOf( -117L ) ) ); } else { value = value.longValue(); expected = -117L; @@ -1244,9 +826,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[11] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[11] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -1254,9 +834,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[12] + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[12] + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1264,9 +842,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[13] + "' != '" + -64 + "'", - value.equals(BigInteger.valueOf(-64L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[13] + "' != '" + -64 + "'", value.equals(BigInteger.valueOf( -64L ) ) ); } else { value = value.longValue(); expected = -64L; @@ -1274,9 +850,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[14] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[14] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -1284,9 +858,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[15] + "' != '" + 85 + "'", - value.equals(BigInteger.valueOf(85L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[15] + "' != '" + 85 + "'", value.equals(BigInteger.valueOf( 85L ) ) ); } else { value = value.longValue(); expected = 85L; @@ -1294,9 +866,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[16] + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[16] + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -1304,9 +874,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[17] + "' != '" + -28 + "'", - value.equals(BigInteger.valueOf(-28L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[17] + "' != '" + -28 + "'", value.equals(BigInteger.valueOf( -28L ) ) ); } else { value = value.longValue(); expected = -28L; @@ -1314,9 +882,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[18] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[18] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -1324,9 +890,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[19] + "' != '" + -4 + "'", - value.equals(BigInteger.valueOf(-4L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[19] + "' != '" + -4 + "'", value.equals(BigInteger.valueOf( -4L ) ) ); } else { value = value.longValue(); expected = -4L; @@ -1334,9 +898,7 @@ public void test1() throws Throwable { } value = msg.apc[3].pcv[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].pcv[20] + "' != '" + -37 + "'", - value.equals(BigInteger.valueOf(-37L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].pcv[20] + "' != '" + -37 + "'", value.equals(BigInteger.valueOf( -37L ) ) ); } else { value = value.longValue(); expected = -37L; @@ -1344,9 +906,7 @@ public void test1() throws Throwable { } value = msg.apc[3].sat_info; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].sat_info + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].sat_info + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -1354,9 +914,7 @@ public void test1() throws Throwable { } value = msg.apc[3].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].sid.code + "' != '" + 196 + "'", - value.equals(BigInteger.valueOf(196L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].sid.code + "' != '" + 196 + "'", value.equals(BigInteger.valueOf( 196L ) ) ); } else { value = value.longValue(); expected = 196L; @@ -1364,9 +922,7 @@ public void test1() throws Throwable { } value = msg.apc[3].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].sid.sat + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].sid.sat + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1374,9 +930,7 @@ public void test1() throws Throwable { } value = msg.apc[3].svn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[3].svn + "' != '" + 61399 + "'", - value.equals(BigInteger.valueOf(61399L))); + org.junit.Assert.assertTrue("'" + msg.apc[3].svn + "' != '" + 61399 + "'", value.equals(BigInteger.valueOf( 61399L ) ) ); } else { value = value.longValue(); expected = 61399L; @@ -1384,9 +938,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pco[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pco[0] + "' != '" + -11049 + "'", - value.equals(BigInteger.valueOf(-11049L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pco[0] + "' != '" + -11049 + "'", value.equals(BigInteger.valueOf( -11049L ) ) ); } else { value = value.longValue(); expected = -11049L; @@ -1394,9 +946,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pco[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pco[1] + "' != '" + 6580 + "'", - value.equals(BigInteger.valueOf(6580L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pco[1] + "' != '" + 6580 + "'", value.equals(BigInteger.valueOf( 6580L ) ) ); } else { value = value.longValue(); expected = 6580L; @@ -1404,9 +954,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pco[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pco[2] + "' != '" + -28589 + "'", - value.equals(BigInteger.valueOf(-28589L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pco[2] + "' != '" + -28589 + "'", value.equals(BigInteger.valueOf( -28589L ) ) ); } else { value = value.longValue(); expected = -28589L; @@ -1414,9 +962,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[0] + "' != '" + -9 + "'", - value.equals(BigInteger.valueOf(-9L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[0] + "' != '" + -9 + "'", value.equals(BigInteger.valueOf( -9L ) ) ); } else { value = value.longValue(); expected = -9L; @@ -1424,9 +970,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[1] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[1] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1434,9 +978,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[2] + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[2] + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -1444,9 +986,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[3] + "' != '" + -57 + "'", - value.equals(BigInteger.valueOf(-57L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[3] + "' != '" + -57 + "'", value.equals(BigInteger.valueOf( -57L ) ) ); } else { value = value.longValue(); expected = -57L; @@ -1454,9 +994,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[4] + "' != '" + -83 + "'", - value.equals(BigInteger.valueOf(-83L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[4] + "' != '" + -83 + "'", value.equals(BigInteger.valueOf( -83L ) ) ); } else { value = value.longValue(); expected = -83L; @@ -1464,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[5] + "' != '" + 74 + "'", - value.equals(BigInteger.valueOf(74L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[5] + "' != '" + 74 + "'", value.equals(BigInteger.valueOf( 74L ) ) ); } else { value = value.longValue(); expected = 74L; @@ -1474,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[6] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[6] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1484,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[7] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[7] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1494,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[8] + "' != '" + -17 + "'", - value.equals(BigInteger.valueOf(-17L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[8] + "' != '" + -17 + "'", value.equals(BigInteger.valueOf( -17L ) ) ); } else { value = value.longValue(); expected = -17L; @@ -1504,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[9] + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[9] + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -1514,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[10] + "' != '" + -33 + "'", - value.equals(BigInteger.valueOf(-33L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[10] + "' != '" + -33 + "'", value.equals(BigInteger.valueOf( -33L ) ) ); } else { value = value.longValue(); expected = -33L; @@ -1524,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[11] + "' != '" + -36 + "'", - value.equals(BigInteger.valueOf(-36L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[11] + "' != '" + -36 + "'", value.equals(BigInteger.valueOf( -36L ) ) ); } else { value = value.longValue(); expected = -36L; @@ -1534,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[12] + "' != '" + -117 + "'", - value.equals(BigInteger.valueOf(-117L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[12] + "' != '" + -117 + "'", value.equals(BigInteger.valueOf( -117L ) ) ); } else { value = value.longValue(); expected = -117L; @@ -1544,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[13] + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[13] + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -1554,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[14] + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[14] + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -1564,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[15] + "' != '" + -42 + "'", - value.equals(BigInteger.valueOf(-42L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[15] + "' != '" + -42 + "'", value.equals(BigInteger.valueOf( -42L ) ) ); } else { value = value.longValue(); expected = -42L; @@ -1574,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[16] + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[16] + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -1584,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[17] + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[17] + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -1594,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[18] + "' != '" + -53 + "'", - value.equals(BigInteger.valueOf(-53L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[18] + "' != '" + -53 + "'", value.equals(BigInteger.valueOf( -53L ) ) ); } else { value = value.longValue(); expected = -53L; @@ -1604,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[19] + "' != '" + -28 + "'", - value.equals(BigInteger.valueOf(-28L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[19] + "' != '" + -28 + "'", value.equals(BigInteger.valueOf( -28L ) ) ); } else { value = value.longValue(); expected = -28L; @@ -1614,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.apc[4].pcv[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].pcv[20] + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].pcv[20] + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -1624,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.apc[4].sat_info; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].sat_info + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].sat_info + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -1634,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.apc[4].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].sid.code + "' != '" + 110 + "'", - value.equals(BigInteger.valueOf(110L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].sid.code + "' != '" + 110 + "'", value.equals(BigInteger.valueOf( 110L ) ) ); } else { value = value.longValue(); expected = 110L; @@ -1644,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.apc[4].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].sid.sat + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].sid.sat + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -1654,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.apc[4].svn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[4].svn + "' != '" + 41224 + "'", - value.equals(BigInteger.valueOf(41224L))); + org.junit.Assert.assertTrue("'" + msg.apc[4].svn + "' != '" + 41224 + "'", value.equals(BigInteger.valueOf( 41224L ) ) ); } else { value = value.longValue(); expected = 41224L; @@ -1664,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pco[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pco[0] + "' != '" + -21881 + "'", - value.equals(BigInteger.valueOf(-21881L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pco[0] + "' != '" + -21881 + "'", value.equals(BigInteger.valueOf( -21881L ) ) ); } else { value = value.longValue(); expected = -21881L; @@ -1674,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pco[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pco[1] + "' != '" + -9942 + "'", - value.equals(BigInteger.valueOf(-9942L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pco[1] + "' != '" + -9942 + "'", value.equals(BigInteger.valueOf( -9942L ) ) ); } else { value = value.longValue(); expected = -9942L; @@ -1684,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pco[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pco[2] + "' != '" + -5689 + "'", - value.equals(BigInteger.valueOf(-5689L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pco[2] + "' != '" + -5689 + "'", value.equals(BigInteger.valueOf( -5689L ) ) ); } else { value = value.longValue(); expected = -5689L; @@ -1694,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[0] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[0] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -1704,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[1] + "' != '" + -86 + "'", - value.equals(BigInteger.valueOf(-86L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[1] + "' != '" + -86 + "'", value.equals(BigInteger.valueOf( -86L ) ) ); } else { value = value.longValue(); expected = -86L; @@ -1714,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[2] + "' != '" + 78 + "'", - value.equals(BigInteger.valueOf(78L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[2] + "' != '" + 78 + "'", value.equals(BigInteger.valueOf( 78L ) ) ); } else { value = value.longValue(); expected = 78L; @@ -1724,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[3] + "' != '" + -50 + "'", - value.equals(BigInteger.valueOf(-50L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[3] + "' != '" + -50 + "'", value.equals(BigInteger.valueOf( -50L ) ) ); } else { value = value.longValue(); expected = -50L; @@ -1734,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[4] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[4] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -1744,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[5] + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[5] + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -1754,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[6] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[6] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -1764,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[7] + "' != '" + -9 + "'", - value.equals(BigInteger.valueOf(-9L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[7] + "' != '" + -9 + "'", value.equals(BigInteger.valueOf( -9L ) ) ); } else { value = value.longValue(); expected = -9L; @@ -1774,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[8] + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[8] + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -1784,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[9] + "' != '" + -58 + "'", - value.equals(BigInteger.valueOf(-58L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[9] + "' != '" + -58 + "'", value.equals(BigInteger.valueOf( -58L ) ) ); } else { value = value.longValue(); expected = -58L; @@ -1794,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[10] + "' != '" + -112 + "'", - value.equals(BigInteger.valueOf(-112L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[10] + "' != '" + -112 + "'", value.equals(BigInteger.valueOf( -112L ) ) ); } else { value = value.longValue(); expected = -112L; @@ -1804,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[11] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[11] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1814,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[12] + "' != '" + -124 + "'", - value.equals(BigInteger.valueOf(-124L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[12] + "' != '" + -124 + "'", value.equals(BigInteger.valueOf( -124L ) ) ); } else { value = value.longValue(); expected = -124L; @@ -1824,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[13] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[13] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1834,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[14] + "' != '" + -32 + "'", - value.equals(BigInteger.valueOf(-32L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[14] + "' != '" + -32 + "'", value.equals(BigInteger.valueOf( -32L ) ) ); } else { value = value.longValue(); expected = -32L; @@ -1844,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[15] + "' != '" + -36 + "'", - value.equals(BigInteger.valueOf(-36L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[15] + "' != '" + -36 + "'", value.equals(BigInteger.valueOf( -36L ) ) ); } else { value = value.longValue(); expected = -36L; @@ -1854,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[16] + "' != '" + -108 + "'", - value.equals(BigInteger.valueOf(-108L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[16] + "' != '" + -108 + "'", value.equals(BigInteger.valueOf( -108L ) ) ); } else { value = value.longValue(); expected = -108L; @@ -1864,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[17] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[17] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -1874,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[18] + "' != '" + 85 + "'", - value.equals(BigInteger.valueOf(85L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[18] + "' != '" + 85 + "'", value.equals(BigInteger.valueOf( 85L ) ) ); } else { value = value.longValue(); expected = 85L; @@ -1884,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[19] + "' != '" + -118 + "'", - value.equals(BigInteger.valueOf(-118L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[19] + "' != '" + -118 + "'", value.equals(BigInteger.valueOf( -118L ) ) ); } else { value = value.longValue(); expected = -118L; @@ -1894,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.apc[5].pcv[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].pcv[20] + "' != '" + -46 + "'", - value.equals(BigInteger.valueOf(-46L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].pcv[20] + "' != '" + -46 + "'", value.equals(BigInteger.valueOf( -46L ) ) ); } else { value = value.longValue(); expected = -46L; @@ -1904,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.apc[5].sat_info; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].sat_info + "' != '" + 159 + "'", - value.equals(BigInteger.valueOf(159L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].sat_info + "' != '" + 159 + "'", value.equals(BigInteger.valueOf( 159L ) ) ); } else { value = value.longValue(); expected = 159L; @@ -1914,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.apc[5].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].sid.code + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].sid.code + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -1924,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.apc[5].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].sid.sat + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].sid.sat + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -1934,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.apc[5].svn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[5].svn + "' != '" + 64011 + "'", - value.equals(BigInteger.valueOf(64011L))); + org.junit.Assert.assertTrue("'" + msg.apc[5].svn + "' != '" + 64011 + "'", value.equals(BigInteger.valueOf( 64011L ) ) ); } else { value = value.longValue(); expected = 64011L; @@ -1944,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pco[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pco[0] + "' != '" + -14290 + "'", - value.equals(BigInteger.valueOf(-14290L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pco[0] + "' != '" + -14290 + "'", value.equals(BigInteger.valueOf( -14290L ) ) ); } else { value = value.longValue(); expected = -14290L; @@ -1954,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pco[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pco[1] + "' != '" + 30340 + "'", - value.equals(BigInteger.valueOf(30340L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pco[1] + "' != '" + 30340 + "'", value.equals(BigInteger.valueOf( 30340L ) ) ); } else { value = value.longValue(); expected = 30340L; @@ -1964,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pco[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pco[2] + "' != '" + 3569 + "'", - value.equals(BigInteger.valueOf(3569L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pco[2] + "' != '" + 3569 + "'", value.equals(BigInteger.valueOf( 3569L ) ) ); } else { value = value.longValue(); expected = 3569L; @@ -1974,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[0] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[0] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -1984,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[1] + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[1] + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -1994,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[2] + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[2] + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -2004,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[3] + "' != '" + -3 + "'", - value.equals(BigInteger.valueOf(-3L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[3] + "' != '" + -3 + "'", value.equals(BigInteger.valueOf( -3L ) ) ); } else { value = value.longValue(); expected = -3L; @@ -2014,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[4] + "' != '" + -66 + "'", - value.equals(BigInteger.valueOf(-66L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[4] + "' != '" + -66 + "'", value.equals(BigInteger.valueOf( -66L ) ) ); } else { value = value.longValue(); expected = -66L; @@ -2024,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[5] + "' != '" + -120 + "'", - value.equals(BigInteger.valueOf(-120L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[5] + "' != '" + -120 + "'", value.equals(BigInteger.valueOf( -120L ) ) ); } else { value = value.longValue(); expected = -120L; @@ -2034,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[6] + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[6] + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -2044,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[7] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[7] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -2054,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[8] + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[8] + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -2064,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[9] + "' != '" + -101 + "'", - value.equals(BigInteger.valueOf(-101L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[9] + "' != '" + -101 + "'", value.equals(BigInteger.valueOf( -101L ) ) ); } else { value = value.longValue(); expected = -101L; @@ -2074,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[10] + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[10] + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -2084,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[11] + "' != '" + -76 + "'", - value.equals(BigInteger.valueOf(-76L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[11] + "' != '" + -76 + "'", value.equals(BigInteger.valueOf( -76L ) ) ); } else { value = value.longValue(); expected = -76L; @@ -2094,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[12] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[12] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -2104,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[13] + "' != '" + -60 + "'", - value.equals(BigInteger.valueOf(-60L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[13] + "' != '" + -60 + "'", value.equals(BigInteger.valueOf( -60L ) ) ); } else { value = value.longValue(); expected = -60L; @@ -2114,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[14] + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[14] + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -2124,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[15] + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[15] + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -2134,9 +1538,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[16] + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[16] + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -2144,9 +1546,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[17] + "' != '" + -4 + "'", - value.equals(BigInteger.valueOf(-4L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[17] + "' != '" + -4 + "'", value.equals(BigInteger.valueOf( -4L ) ) ); } else { value = value.longValue(); expected = -4L; @@ -2154,9 +1554,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[18] + "' != '" + -33 + "'", - value.equals(BigInteger.valueOf(-33L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[18] + "' != '" + -33 + "'", value.equals(BigInteger.valueOf( -33L ) ) ); } else { value = value.longValue(); expected = -33L; @@ -2164,9 +1562,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[19] + "' != '" + -112 + "'", - value.equals(BigInteger.valueOf(-112L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[19] + "' != '" + -112 + "'", value.equals(BigInteger.valueOf( -112L ) ) ); } else { value = value.longValue(); expected = -112L; @@ -2174,9 +1570,7 @@ public void test1() throws Throwable { } value = msg.apc[6].pcv[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].pcv[20] + "' != '" + -103 + "'", - value.equals(BigInteger.valueOf(-103L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].pcv[20] + "' != '" + -103 + "'", value.equals(BigInteger.valueOf( -103L ) ) ); } else { value = value.longValue(); expected = -103L; @@ -2184,9 +1578,7 @@ public void test1() throws Throwable { } value = msg.apc[6].sat_info; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].sat_info + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].sat_info + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -2194,9 +1586,7 @@ public void test1() throws Throwable { } value = msg.apc[6].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].sid.code + "' != '" + 158 + "'", - value.equals(BigInteger.valueOf(158L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].sid.code + "' != '" + 158 + "'", value.equals(BigInteger.valueOf( 158L ) ) ); } else { value = value.longValue(); expected = 158L; @@ -2204,9 +1594,7 @@ public void test1() throws Throwable { } value = msg.apc[6].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].sid.sat + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].sid.sat + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -2214,9 +1602,7 @@ public void test1() throws Throwable { } value = msg.apc[6].svn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[6].svn + "' != '" + 17310 + "'", - value.equals(BigInteger.valueOf(17310L))); + org.junit.Assert.assertTrue("'" + msg.apc[6].svn + "' != '" + 17310 + "'", value.equals(BigInteger.valueOf( 17310L ) ) ); } else { value = value.longValue(); expected = 17310L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrSatelliteApcTest.java b/java/test/auto_check_sbp_ssr_MsgSsrSatelliteApcTest.java index 4a04b163f..daf93fa37 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrSatelliteApcTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrSatelliteApcTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrSatelliteApc.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrSatelliteApc.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrSatelliteApc; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrSatelliteApcTest { @@ -27,61 +32,17 @@ public class auto_check_sbp_ssr_MsgSsrSatelliteApcTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrSatelliteApcTest.test1"); - byte[] payload = - new byte[] { - (byte) 127, - (byte) 58, - (byte) 9, - (byte) 0, - (byte) 174, - (byte) 8, - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 2, - (byte) 0, - (byte) 4, - (byte) 61, - (byte) 0, - (byte) 1, - (byte) 0, - (byte) 255, - (byte) 255, - (byte) 217, - (byte) 2, - (byte) 11, - (byte) 10, - (byte) 8, - (byte) 5, - (byte) 1, - (byte) 252, - (byte) 248, - (byte) 246, - (byte) 246, - (byte) 246, - (byte) 249, - (byte) 252, - (byte) 0, - (byte) 6, - (byte) 12, - (byte) 22, - (byte) 30, - (byte) 41, - (byte) 41, - (byte) 41, - (byte) 41, - }; - SBPMessage sbp = new SBPMessage(0x0, 0x605, payload); - MsgSsrSatelliteApc msg = new MsgSsrSatelliteApc(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrSatelliteApcTest.test1"); + byte[] payload = new byte[] {(byte)127,(byte)58,(byte)9,(byte)0,(byte)174,(byte)8,(byte)1,(byte)2,(byte)3,(byte)2,(byte)0,(byte)4,(byte)61,(byte)0,(byte)1,(byte)0,(byte)255,(byte)255,(byte)217,(byte)2,(byte)11,(byte)10,(byte)8,(byte)5,(byte)1,(byte)252,(byte)248,(byte)246,(byte)246,(byte)246,(byte)249,(byte)252,(byte)0,(byte)6,(byte)12,(byte)22,(byte)30,(byte)41,(byte)41,(byte)41,(byte)41, }; + SBPMessage sbp = new SBPMessage( 0x0, 0x605, payload ); + MsgSsrSatelliteApc msg = new MsgSsrSatelliteApc( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.apc[0].pco[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pco[0] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pco[0] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -89,9 +50,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pco[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pco[1] + "' != '" + -1 + "'", - value.equals(BigInteger.valueOf(-1L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pco[1] + "' != '" + -1 + "'", value.equals(BigInteger.valueOf( -1L ) ) ); } else { value = value.longValue(); expected = -1L; @@ -99,9 +58,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pco[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pco[2] + "' != '" + 729 + "'", - value.equals(BigInteger.valueOf(729L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pco[2] + "' != '" + 729 + "'", value.equals(BigInteger.valueOf( 729L ) ) ); } else { value = value.longValue(); expected = 729L; @@ -109,9 +66,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[0] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[0] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -119,9 +74,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[1] + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[1] + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -129,9 +82,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[2] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[2] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -139,9 +90,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[3] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[3] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -149,9 +98,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[4] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[4] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -159,9 +106,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[5] + "' != '" + -4 + "'", - value.equals(BigInteger.valueOf(-4L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[5] + "' != '" + -4 + "'", value.equals(BigInteger.valueOf( -4L ) ) ); } else { value = value.longValue(); expected = -4L; @@ -169,9 +114,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[6] + "' != '" + -8 + "'", - value.equals(BigInteger.valueOf(-8L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[6] + "' != '" + -8 + "'", value.equals(BigInteger.valueOf( -8L ) ) ); } else { value = value.longValue(); expected = -8L; @@ -179,9 +122,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[7] + "' != '" + -10 + "'", - value.equals(BigInteger.valueOf(-10L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[7] + "' != '" + -10 + "'", value.equals(BigInteger.valueOf( -10L ) ) ); } else { value = value.longValue(); expected = -10L; @@ -189,9 +130,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[8] + "' != '" + -10 + "'", - value.equals(BigInteger.valueOf(-10L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[8] + "' != '" + -10 + "'", value.equals(BigInteger.valueOf( -10L ) ) ); } else { value = value.longValue(); expected = -10L; @@ -199,9 +138,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[9] + "' != '" + -10 + "'", - value.equals(BigInteger.valueOf(-10L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[9] + "' != '" + -10 + "'", value.equals(BigInteger.valueOf( -10L ) ) ); } else { value = value.longValue(); expected = -10L; @@ -209,9 +146,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[10] + "' != '" + -7 + "'", - value.equals(BigInteger.valueOf(-7L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[10] + "' != '" + -7 + "'", value.equals(BigInteger.valueOf( -7L ) ) ); } else { value = value.longValue(); expected = -7L; @@ -219,9 +154,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[11] + "' != '" + -4 + "'", - value.equals(BigInteger.valueOf(-4L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[11] + "' != '" + -4 + "'", value.equals(BigInteger.valueOf( -4L ) ) ); } else { value = value.longValue(); expected = -4L; @@ -229,9 +162,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[12] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[12] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -239,9 +170,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[13] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[13] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -249,9 +178,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[14] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[14] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -259,9 +186,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[15] + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[15] + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -269,9 +194,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[16] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[16] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -279,9 +202,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[17] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[17] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -289,9 +210,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[18] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[18] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -299,9 +218,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[19] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[19] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -309,9 +226,7 @@ public void test1() throws Throwable { } value = msg.apc[0].pcv[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].pcv[20] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].pcv[20] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -319,9 +234,7 @@ public void test1() throws Throwable { } value = msg.apc[0].sat_info; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].sat_info + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].sat_info + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -329,9 +242,7 @@ public void test1() throws Throwable { } value = msg.apc[0].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -339,9 +250,7 @@ public void test1() throws Throwable { } value = msg.apc[0].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].sid.sat + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].sid.sat + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -349,9 +258,7 @@ public void test1() throws Throwable { } value = msg.apc[0].svn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.apc[0].svn + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.apc[0].svn + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -359,8 +266,7 @@ public void test1() throws Throwable { } value = msg.iod_ssr; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.iod_ssr + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.iod_ssr + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -368,8 +274,7 @@ public void test1() throws Throwable { } value = msg.sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_id + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.sol_id + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -377,9 +282,7 @@ public void test1() throws Throwable { } value = msg.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time.tow + "' != '" + 604799 + "'", - value.equals(BigInteger.valueOf(604799L))); + org.junit.Assert.assertTrue("'" + msg.time.tow + "' != '" + 604799 + "'", value.equals(BigInteger.valueOf( 604799L ) ) ); } else { value = value.longValue(); expected = 604799L; @@ -387,9 +290,7 @@ public void test1() throws Throwable { } value = msg.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time.wn + "' != '" + 2222 + "'", - value.equals(BigInteger.valueOf(2222L))); + org.junit.Assert.assertTrue("'" + msg.time.wn + "' != '" + 2222 + "'", value.equals(BigInteger.valueOf( 2222L ) ) ); } else { value = value.longValue(); expected = 2222L; @@ -397,9 +298,7 @@ public void test1() throws Throwable { } value = msg.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.update_interval + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.update_interval + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionDepATest.java b/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionDepATest.java index b691ef00a..959c09650 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionDepATest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrectionDepA.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrectionDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrStecCorrectionDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrStecCorrectionDepATest { @@ -30,271 +34,15 @@ public class auto_check_sbp_ssr_MsgSsrStecCorrectionDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrStecCorrectionDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 70, - (byte) 81, - (byte) 196, - (byte) 232, - (byte) 185, - (byte) 43, - (byte) 147, - (byte) 123, - (byte) 39, - (byte) 4, - (byte) 126, - (byte) 19, - (byte) 111, - (byte) 97, - (byte) 248, - (byte) 130, - (byte) 217, - (byte) 217, - (byte) 106, - (byte) 58, - (byte) 12, - (byte) 65, - (byte) 230, - (byte) 171, - (byte) 81, - (byte) 95, - (byte) 86, - (byte) 16, - (byte) 39, - (byte) 84, - (byte) 228, - (byte) 208, - (byte) 201, - (byte) 81, - (byte) 219, - (byte) 99, - (byte) 203, - (byte) 61, - (byte) 182, - (byte) 66, - (byte) 125, - (byte) 203, - (byte) 3, - (byte) 193, - (byte) 44, - (byte) 100, - (byte) 220, - (byte) 125, - (byte) 60, - (byte) 21, - (byte) 93, - (byte) 218, - (byte) 247, - (byte) 158, - (byte) 207, - (byte) 93, - (byte) 129, - (byte) 134, - (byte) 14, - (byte) 209, - (byte) 48, - (byte) 14, - (byte) 215, - (byte) 153, - (byte) 148, - (byte) 147, - (byte) 72, - (byte) 225, - (byte) 180, - (byte) 236, - (byte) 205, - (byte) 201, - (byte) 33, - (byte) 3, - (byte) 246, - (byte) 204, - (byte) 19, - (byte) 3, - (byte) 98, - (byte) 4, - (byte) 194, - (byte) 191, - (byte) 246, - (byte) 76, - (byte) 219, - (byte) 31, - (byte) 191, - (byte) 113, - (byte) 79, - (byte) 177, - (byte) 15, - (byte) 251, - (byte) 33, - (byte) 19, - (byte) 96, - (byte) 54, - (byte) 58, - (byte) 146, - (byte) 210, - (byte) 100, - (byte) 249, - (byte) 72, - (byte) 21, - (byte) 161, - (byte) 211, - (byte) 198, - (byte) 21, - (byte) 238, - (byte) 111, - (byte) 107, - (byte) 36, - (byte) 227, - (byte) 225, - (byte) 213, - (byte) 3, - (byte) 71, - (byte) 243, - (byte) 63, - (byte) 65, - (byte) 236, - (byte) 92, - (byte) 77, - (byte) 0, - (byte) 169, - (byte) 15, - (byte) 182, - (byte) 5, - (byte) 240, - (byte) 180, - (byte) 9, - (byte) 122, - (byte) 86, - (byte) 232, - (byte) 6, - (byte) 103, - (byte) 104, - (byte) 254, - (byte) 189, - (byte) 81, - (byte) 110, - (byte) 2, - (byte) 49, - (byte) 202, - (byte) 84, - (byte) 216, - (byte) 55, - (byte) 50, - (byte) 181, - (byte) 5, - (byte) 123, - (byte) 80, - (byte) 49, - (byte) 244, - (byte) 224, - (byte) 188, - (byte) 125, - (byte) 164, - (byte) 230, - (byte) 56, - (byte) 66, - (byte) 124, - (byte) 168, - (byte) 59, - (byte) 139, - (byte) 106, - (byte) 118, - (byte) 51, - (byte) 187, - (byte) 216, - (byte) 191, - (byte) 158, - (byte) 77, - (byte) 92, - (byte) 58, - (byte) 253, - (byte) 132, - (byte) 150, - (byte) 165, - (byte) 9, - (byte) 154, - (byte) 189, - (byte) 218, - (byte) 61, - (byte) 209, - (byte) 1, - (byte) 82, - (byte) 181, - (byte) 196, - (byte) 23, - (byte) 53, - (byte) 182, - (byte) 112, - (byte) 192, - (byte) 206, - (byte) 167, - (byte) 157, - (byte) 244, - (byte) 35, - (byte) 1, - (byte) 189, - (byte) 217, - (byte) 61, - (byte) 88, - (byte) 97, - (byte) 201, - (byte) 201, - (byte) 74, - (byte) 251, - (byte) 217, - (byte) 14, - (byte) 104, - (byte) 184, - (byte) 54, - (byte) 52, - (byte) 74, - (byte) 238, - (byte) 10, - (byte) 129, - (byte) 22, - (byte) 178, - (byte) 226, - (byte) 109, - (byte) 88, - (byte) 157, - (byte) 30, - (byte) 196, - (byte) 175, - (byte) 26, - (byte) 76, - (byte) 34, - (byte) 116, - (byte) 220, - (byte) 154, - (byte) 232, - (byte) 12, - (byte) 179, - (byte) 244, - (byte) 15, - (byte) 155, - (byte) 196, - (byte) 202, - (byte) 72, - (byte) 70, - (byte) 115, - (byte) 10, - (byte) 214, - (byte) 114, - (byte) 39, - (byte) 245, - (byte) 28, - (byte) 237, - (byte) 68, - }; - SBPMessage sbp = new SBPMessage(0x0727, 0x5eb, payload); - MsgSsrStecCorrectionDepA msg = new MsgSsrStecCorrectionDepA(sbp); + byte[] payload = new byte[] {(byte)70,(byte)81,(byte)196,(byte)232,(byte)185,(byte)43,(byte)147,(byte)123,(byte)39,(byte)4,(byte)126,(byte)19,(byte)111,(byte)97,(byte)248,(byte)130,(byte)217,(byte)217,(byte)106,(byte)58,(byte)12,(byte)65,(byte)230,(byte)171,(byte)81,(byte)95,(byte)86,(byte)16,(byte)39,(byte)84,(byte)228,(byte)208,(byte)201,(byte)81,(byte)219,(byte)99,(byte)203,(byte)61,(byte)182,(byte)66,(byte)125,(byte)203,(byte)3,(byte)193,(byte)44,(byte)100,(byte)220,(byte)125,(byte)60,(byte)21,(byte)93,(byte)218,(byte)247,(byte)158,(byte)207,(byte)93,(byte)129,(byte)134,(byte)14,(byte)209,(byte)48,(byte)14,(byte)215,(byte)153,(byte)148,(byte)147,(byte)72,(byte)225,(byte)180,(byte)236,(byte)205,(byte)201,(byte)33,(byte)3,(byte)246,(byte)204,(byte)19,(byte)3,(byte)98,(byte)4,(byte)194,(byte)191,(byte)246,(byte)76,(byte)219,(byte)31,(byte)191,(byte)113,(byte)79,(byte)177,(byte)15,(byte)251,(byte)33,(byte)19,(byte)96,(byte)54,(byte)58,(byte)146,(byte)210,(byte)100,(byte)249,(byte)72,(byte)21,(byte)161,(byte)211,(byte)198,(byte)21,(byte)238,(byte)111,(byte)107,(byte)36,(byte)227,(byte)225,(byte)213,(byte)3,(byte)71,(byte)243,(byte)63,(byte)65,(byte)236,(byte)92,(byte)77,(byte)0,(byte)169,(byte)15,(byte)182,(byte)5,(byte)240,(byte)180,(byte)9,(byte)122,(byte)86,(byte)232,(byte)6,(byte)103,(byte)104,(byte)254,(byte)189,(byte)81,(byte)110,(byte)2,(byte)49,(byte)202,(byte)84,(byte)216,(byte)55,(byte)50,(byte)181,(byte)5,(byte)123,(byte)80,(byte)49,(byte)244,(byte)224,(byte)188,(byte)125,(byte)164,(byte)230,(byte)56,(byte)66,(byte)124,(byte)168,(byte)59,(byte)139,(byte)106,(byte)118,(byte)51,(byte)187,(byte)216,(byte)191,(byte)158,(byte)77,(byte)92,(byte)58,(byte)253,(byte)132,(byte)150,(byte)165,(byte)9,(byte)154,(byte)189,(byte)218,(byte)61,(byte)209,(byte)1,(byte)82,(byte)181,(byte)196,(byte)23,(byte)53,(byte)182,(byte)112,(byte)192,(byte)206,(byte)167,(byte)157,(byte)244,(byte)35,(byte)1,(byte)189,(byte)217,(byte)61,(byte)88,(byte)97,(byte)201,(byte)201,(byte)74,(byte)251,(byte)217,(byte)14,(byte)104,(byte)184,(byte)54,(byte)52,(byte)74,(byte)238,(byte)10,(byte)129,(byte)22,(byte)178,(byte)226,(byte)109,(byte)88,(byte)157,(byte)30,(byte)196,(byte)175,(byte)26,(byte)76,(byte)34,(byte)116,(byte)220,(byte)154,(byte)232,(byte)12,(byte)179,(byte)244,(byte)15,(byte)155,(byte)196,(byte)202,(byte)72,(byte)70,(byte)115,(byte)10,(byte)214,(byte)114,(byte)39,(byte)245,(byte)28,(byte)237,(byte)68, }; + SBPMessage sbp = new SBPMessage( 0x0727, 0x5eb, payload ); + MsgSsrStecCorrectionDepA msg = new MsgSsrStecCorrectionDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.header.iod_atmo; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.iod_atmo + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.header.iod_atmo + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -302,9 +50,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -312,9 +58,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -322,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.tow + "' != '" + 3905179974L + "'", - value.equals(new BigInteger("3905179974"))); + org.junit.Assert.assertTrue("'" + msg.header.time.tow + "' != '" + 3905179974L + "'", value.equals( new BigInteger( "3905179974" ) ) ); } else { value = value.longValue(); expected = 3905179974L; @@ -332,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.wn + "' != '" + 11193 + "'", - value.equals(BigInteger.valueOf(11193L))); + org.junit.Assert.assertTrue("'" + msg.header.time.wn + "' != '" + 11193 + "'", value.equals(BigInteger.valueOf( 11193L ) ) ); } else { value = value.longValue(); expected = 11193L; @@ -342,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.update_interval + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.header.update_interval + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -352,9 +90,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_coeff[0] + "' != '" + -1951 + "'", - value.equals(BigInteger.valueOf(-1951L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_coeff[0] + "' != '" + -1951 + "'", value.equals(BigInteger.valueOf( -1951L ) ) ); } else { value = value.longValue(); expected = -1951L; @@ -362,9 +98,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_coeff[1] + "' != '" + -9854 + "'", - value.equals(BigInteger.valueOf(-9854L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_coeff[1] + "' != '" + -9854 + "'", value.equals(BigInteger.valueOf( -9854L ) ) ); } else { value = value.longValue(); expected = -9854L; @@ -372,9 +106,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_coeff[2] + "' != '" + 27353 + "'", - value.equals(BigInteger.valueOf(27353L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_coeff[2] + "' != '" + 27353 + "'", value.equals(BigInteger.valueOf( 27353L ) ) ); } else { value = value.longValue(); expected = 27353L; @@ -382,9 +114,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_coeff[3] + "' != '" + 3130 + "'", - value.equals(BigInteger.valueOf(3130L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_coeff[3] + "' != '" + 3130 + "'", value.equals(BigInteger.valueOf( 3130L ) ) ); } else { value = value.longValue(); expected = 3130L; @@ -392,9 +122,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_quality_indicator + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_quality_indicator + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -402,9 +130,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].sv_id.constellation + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].sv_id.constellation + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -412,9 +138,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].sv_id.satId + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].sv_id.satId + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -422,9 +146,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_coeff[0] + "' != '" + 24401 + "'", - value.equals(BigInteger.valueOf(24401L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_coeff[0] + "' != '" + 24401 + "'", value.equals(BigInteger.valueOf( 24401L ) ) ); } else { value = value.longValue(); expected = 24401L; @@ -432,9 +154,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_coeff[1] + "' != '" + 4182 + "'", - value.equals(BigInteger.valueOf(4182L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_coeff[1] + "' != '" + 4182 + "'", value.equals(BigInteger.valueOf( 4182L ) ) ); } else { value = value.longValue(); expected = 4182L; @@ -442,9 +162,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_coeff[2] + "' != '" + 21543 + "'", - value.equals(BigInteger.valueOf(21543L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_coeff[2] + "' != '" + 21543 + "'", value.equals(BigInteger.valueOf( 21543L ) ) ); } else { value = value.longValue(); expected = 21543L; @@ -452,9 +170,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_coeff[3] + "' != '" + -12060 + "'", - value.equals(BigInteger.valueOf(-12060L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_coeff[3] + "' != '" + -12060 + "'", value.equals(BigInteger.valueOf( -12060L ) ) ); } else { value = value.longValue(); expected = -12060L; @@ -462,9 +178,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_quality_indicator + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_quality_indicator + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -472,9 +186,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].sv_id.constellation + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].sv_id.constellation + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -482,9 +194,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].sv_id.satId + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].sv_id.satId + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -492,9 +202,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].stec_coeff[0] + "' != '" + -13469 + "'", - value.equals(BigInteger.valueOf(-13469L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].stec_coeff[0] + "' != '" + -13469 + "'", value.equals(BigInteger.valueOf( -13469L ) ) ); } else { value = value.longValue(); expected = -13469L; @@ -502,9 +210,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].stec_coeff[1] + "' != '" + -18883 + "'", - value.equals(BigInteger.valueOf(-18883L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].stec_coeff[1] + "' != '" + -18883 + "'", value.equals(BigInteger.valueOf( -18883L ) ) ); } else { value = value.longValue(); expected = -18883L; @@ -512,9 +218,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].stec_coeff[2] + "' != '" + 32066 + "'", - value.equals(BigInteger.valueOf(32066L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].stec_coeff[2] + "' != '" + 32066 + "'", value.equals(BigInteger.valueOf( 32066L ) ) ); } else { value = value.longValue(); expected = 32066L; @@ -522,9 +226,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].stec_coeff[3] + "' != '" + 971 + "'", - value.equals(BigInteger.valueOf(971L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].stec_coeff[3] + "' != '" + 971 + "'", value.equals(BigInteger.valueOf( 971L ) ) ); } else { value = value.longValue(); expected = 971L; @@ -532,9 +234,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].stec_quality_indicator + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].stec_quality_indicator + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -542,9 +242,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].sv_id.constellation + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].sv_id.constellation + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -552,9 +250,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].sv_id.satId + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].sv_id.satId + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -562,9 +258,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].stec_coeff[0] + "' != '" + 32220 + "'", - value.equals(BigInteger.valueOf(32220L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].stec_coeff[0] + "' != '" + 32220 + "'", value.equals(BigInteger.valueOf( 32220L ) ) ); } else { value = value.longValue(); expected = 32220L; @@ -572,9 +266,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].stec_coeff[1] + "' != '" + 5436 + "'", - value.equals(BigInteger.valueOf(5436L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].stec_coeff[1] + "' != '" + 5436 + "'", value.equals(BigInteger.valueOf( 5436L ) ) ); } else { value = value.longValue(); expected = 5436L; @@ -582,9 +274,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].stec_coeff[2] + "' != '" + -9635 + "'", - value.equals(BigInteger.valueOf(-9635L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].stec_coeff[2] + "' != '" + -9635 + "'", value.equals(BigInteger.valueOf( -9635L ) ) ); } else { value = value.longValue(); expected = -9635L; @@ -592,9 +282,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].stec_coeff[3] + "' != '" + -24841 + "'", - value.equals(BigInteger.valueOf(-24841L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].stec_coeff[3] + "' != '" + -24841 + "'", value.equals(BigInteger.valueOf( -24841L ) ) ); } else { value = value.longValue(); expected = -24841L; @@ -602,9 +290,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].stec_quality_indicator + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].stec_quality_indicator + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -612,9 +298,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].sv_id.constellation + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].sv_id.constellation + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -622,9 +306,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].sv_id.satId + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].sv_id.satId + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -632,9 +314,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].stec_coeff[0] + "' != '" + 3718 + "'", - value.equals(BigInteger.valueOf(3718L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].stec_coeff[0] + "' != '" + 3718 + "'", value.equals(BigInteger.valueOf( 3718L ) ) ); } else { value = value.longValue(); expected = 3718L; @@ -642,9 +322,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].stec_coeff[1] + "' != '" + 12497 + "'", - value.equals(BigInteger.valueOf(12497L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].stec_coeff[1] + "' != '" + 12497 + "'", value.equals(BigInteger.valueOf( 12497L ) ) ); } else { value = value.longValue(); expected = 12497L; @@ -652,9 +330,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].stec_coeff[2] + "' != '" + -10482 + "'", - value.equals(BigInteger.valueOf(-10482L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].stec_coeff[2] + "' != '" + -10482 + "'", value.equals(BigInteger.valueOf( -10482L ) ) ); } else { value = value.longValue(); expected = -10482L; @@ -662,9 +338,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].stec_coeff[3] + "' != '" + -27495 + "'", - value.equals(BigInteger.valueOf(-27495L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].stec_coeff[3] + "' != '" + -27495 + "'", value.equals(BigInteger.valueOf( -27495L ) ) ); } else { value = value.longValue(); expected = -27495L; @@ -672,9 +346,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].stec_quality_indicator + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].stec_quality_indicator + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -682,9 +354,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].sv_id.constellation + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].sv_id.constellation + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -692,9 +362,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].sv_id.satId + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].sv_id.satId + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -702,9 +370,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].stec_coeff[0] + "' != '" + -4940 + "'", - value.equals(BigInteger.valueOf(-4940L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].stec_coeff[0] + "' != '" + -4940 + "'", value.equals(BigInteger.valueOf( -4940L ) ) ); } else { value = value.longValue(); expected = -4940L; @@ -712,9 +378,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].stec_coeff[1] + "' != '" + -13875 + "'", - value.equals(BigInteger.valueOf(-13875L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].stec_coeff[1] + "' != '" + -13875 + "'", value.equals(BigInteger.valueOf( -13875L ) ) ); } else { value = value.longValue(); expected = -13875L; @@ -722,9 +386,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].stec_coeff[2] + "' != '" + 801 + "'", - value.equals(BigInteger.valueOf(801L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].stec_coeff[2] + "' != '" + 801 + "'", value.equals(BigInteger.valueOf( 801L ) ) ); } else { value = value.longValue(); expected = 801L; @@ -732,9 +394,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].stec_coeff[3] + "' != '" + -13066 + "'", - value.equals(BigInteger.valueOf(-13066L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].stec_coeff[3] + "' != '" + -13066 + "'", value.equals(BigInteger.valueOf( -13066L ) ) ); } else { value = value.longValue(); expected = -13066L; @@ -742,9 +402,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].stec_quality_indicator + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].stec_quality_indicator + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -752,9 +410,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].sv_id.constellation + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].sv_id.constellation + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -762,9 +418,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].sv_id.satId + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].sv_id.satId + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -772,9 +426,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].stec_coeff[0] + "' != '" + -15868 + "'", - value.equals(BigInteger.valueOf(-15868L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].stec_coeff[0] + "' != '" + -15868 + "'", value.equals(BigInteger.valueOf( -15868L ) ) ); } else { value = value.longValue(); expected = -15868L; @@ -782,9 +434,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].stec_coeff[1] + "' != '" + -2369 + "'", - value.equals(BigInteger.valueOf(-2369L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].stec_coeff[1] + "' != '" + -2369 + "'", value.equals(BigInteger.valueOf( -2369L ) ) ); } else { value = value.longValue(); expected = -2369L; @@ -792,9 +442,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].stec_coeff[2] + "' != '" + -9396 + "'", - value.equals(BigInteger.valueOf(-9396L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].stec_coeff[2] + "' != '" + -9396 + "'", value.equals(BigInteger.valueOf( -9396L ) ) ); } else { value = value.longValue(); expected = -9396L; @@ -802,9 +450,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].stec_coeff[3] + "' != '" + -16609 + "'", - value.equals(BigInteger.valueOf(-16609L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].stec_coeff[3] + "' != '" + -16609 + "'", value.equals(BigInteger.valueOf( -16609L ) ) ); } else { value = value.longValue(); expected = -16609L; @@ -812,9 +458,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].stec_quality_indicator + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].stec_quality_indicator + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -822,9 +466,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].sv_id.constellation + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].sv_id.constellation + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -832,9 +474,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].sv_id.satId + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].sv_id.satId + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -842,9 +482,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].stec_coeff[0] + "' != '" + -1265 + "'", - value.equals(BigInteger.valueOf(-1265L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].stec_coeff[0] + "' != '" + -1265 + "'", value.equals(BigInteger.valueOf( -1265L ) ) ); } else { value = value.longValue(); expected = -1265L; @@ -852,9 +490,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].stec_coeff[1] + "' != '" + 4897 + "'", - value.equals(BigInteger.valueOf(4897L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].stec_coeff[1] + "' != '" + 4897 + "'", value.equals(BigInteger.valueOf( 4897L ) ) ); } else { value = value.longValue(); expected = 4897L; @@ -862,9 +498,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].stec_coeff[2] + "' != '" + 13920 + "'", - value.equals(BigInteger.valueOf(13920L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].stec_coeff[2] + "' != '" + 13920 + "'", value.equals(BigInteger.valueOf( 13920L ) ) ); } else { value = value.longValue(); expected = 13920L; @@ -872,9 +506,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].stec_coeff[3] + "' != '" + -28102 + "'", - value.equals(BigInteger.valueOf(-28102L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].stec_coeff[3] + "' != '" + -28102 + "'", value.equals(BigInteger.valueOf( -28102L ) ) ); } else { value = value.longValue(); expected = -28102L; @@ -882,9 +514,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].stec_quality_indicator + "' != '" + 177 + "'", - value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].stec_quality_indicator + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -892,9 +522,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].sv_id.constellation + "' != '" + 79 + "'", - value.equals(BigInteger.valueOf(79L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].sv_id.constellation + "' != '" + 79 + "'", value.equals(BigInteger.valueOf( 79L ) ) ); } else { value = value.longValue(); expected = 79L; @@ -902,9 +530,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].sv_id.satId + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].sv_id.satId + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -912,9 +538,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].stec_coeff[0] + "' != '" + 5448 + "'", - value.equals(BigInteger.valueOf(5448L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].stec_coeff[0] + "' != '" + 5448 + "'", value.equals(BigInteger.valueOf( 5448L ) ) ); } else { value = value.longValue(); expected = 5448L; @@ -922,9 +546,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].stec_coeff[1] + "' != '" + -11359 + "'", - value.equals(BigInteger.valueOf(-11359L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].stec_coeff[1] + "' != '" + -11359 + "'", value.equals(BigInteger.valueOf( -11359L ) ) ); } else { value = value.longValue(); expected = -11359L; @@ -932,9 +554,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].stec_coeff[2] + "' != '" + 5574 + "'", - value.equals(BigInteger.valueOf(5574L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].stec_coeff[2] + "' != '" + 5574 + "'", value.equals(BigInteger.valueOf( 5574L ) ) ); } else { value = value.longValue(); expected = 5574L; @@ -942,9 +562,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].stec_coeff[3] + "' != '" + 28654 + "'", - value.equals(BigInteger.valueOf(28654L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].stec_coeff[3] + "' != '" + 28654 + "'", value.equals(BigInteger.valueOf( 28654L ) ) ); } else { value = value.longValue(); expected = 28654L; @@ -952,9 +570,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].stec_quality_indicator + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].stec_quality_indicator + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -962,9 +578,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].sv_id.constellation + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].sv_id.constellation + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -972,9 +586,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].sv_id.satId + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].sv_id.satId + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -982,9 +594,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].stec_coeff[0] + "' != '" + -10783 + "'", - value.equals(BigInteger.valueOf(-10783L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].stec_coeff[0] + "' != '" + -10783 + "'", value.equals(BigInteger.valueOf( -10783L ) ) ); } else { value = value.longValue(); expected = -10783L; @@ -992,9 +602,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].stec_coeff[1] + "' != '" + 18179 + "'", - value.equals(BigInteger.valueOf(18179L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].stec_coeff[1] + "' != '" + 18179 + "'", value.equals(BigInteger.valueOf( 18179L ) ) ); } else { value = value.longValue(); expected = 18179L; @@ -1002,9 +610,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].stec_coeff[2] + "' != '" + 16371 + "'", - value.equals(BigInteger.valueOf(16371L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].stec_coeff[2] + "' != '" + 16371 + "'", value.equals(BigInteger.valueOf( 16371L ) ) ); } else { value = value.longValue(); expected = 16371L; @@ -1012,9 +618,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].stec_coeff[3] + "' != '" + -5055 + "'", - value.equals(BigInteger.valueOf(-5055L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].stec_coeff[3] + "' != '" + -5055 + "'", value.equals(BigInteger.valueOf( -5055L ) ) ); } else { value = value.longValue(); expected = -5055L; @@ -1022,9 +626,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].stec_quality_indicator + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].stec_quality_indicator + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1032,9 +634,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].sv_id.constellation + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].sv_id.constellation + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -1042,9 +642,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].sv_id.satId + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].sv_id.satId + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -1052,9 +650,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].stec_coeff[0] + "' != '" + 4009 + "'", - value.equals(BigInteger.valueOf(4009L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].stec_coeff[0] + "' != '" + 4009 + "'", value.equals(BigInteger.valueOf( 4009L ) ) ); } else { value = value.longValue(); expected = 4009L; @@ -1062,9 +658,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].stec_coeff[1] + "' != '" + 1462 + "'", - value.equals(BigInteger.valueOf(1462L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].stec_coeff[1] + "' != '" + 1462 + "'", value.equals(BigInteger.valueOf( 1462L ) ) ); } else { value = value.longValue(); expected = 1462L; @@ -1072,9 +666,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].stec_coeff[2] + "' != '" + -19216 + "'", - value.equals(BigInteger.valueOf(-19216L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].stec_coeff[2] + "' != '" + -19216 + "'", value.equals(BigInteger.valueOf( -19216L ) ) ); } else { value = value.longValue(); expected = -19216L; @@ -1082,9 +674,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].stec_coeff[3] + "' != '" + 31241 + "'", - value.equals(BigInteger.valueOf(31241L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].stec_coeff[3] + "' != '" + 31241 + "'", value.equals(BigInteger.valueOf( 31241L ) ) ); } else { value = value.longValue(); expected = 31241L; @@ -1092,9 +682,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].stec_quality_indicator + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].stec_quality_indicator + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1102,9 +690,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].sv_id.constellation + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].sv_id.constellation + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -1112,9 +698,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].sv_id.satId + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].sv_id.satId + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -1122,9 +706,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].stec_coeff[0] + "' != '" + 26727 + "'", - value.equals(BigInteger.valueOf(26727L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].stec_coeff[0] + "' != '" + 26727 + "'", value.equals(BigInteger.valueOf( 26727L ) ) ); } else { value = value.longValue(); expected = 26727L; @@ -1132,9 +714,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].stec_coeff[1] + "' != '" + -16898 + "'", - value.equals(BigInteger.valueOf(-16898L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].stec_coeff[1] + "' != '" + -16898 + "'", value.equals(BigInteger.valueOf( -16898L ) ) ); } else { value = value.longValue(); expected = -16898L; @@ -1142,9 +722,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].stec_coeff[2] + "' != '" + 28241 + "'", - value.equals(BigInteger.valueOf(28241L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].stec_coeff[2] + "' != '" + 28241 + "'", value.equals(BigInteger.valueOf( 28241L ) ) ); } else { value = value.longValue(); expected = 28241L; @@ -1152,9 +730,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].stec_coeff[3] + "' != '" + 12546 + "'", - value.equals(BigInteger.valueOf(12546L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].stec_coeff[3] + "' != '" + 12546 + "'", value.equals(BigInteger.valueOf( 12546L ) ) ); } else { value = value.longValue(); expected = 12546L; @@ -1162,9 +738,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].stec_quality_indicator + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].stec_quality_indicator + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1172,9 +746,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].sv_id.constellation + "' != '" + 232 + "'", - value.equals(BigInteger.valueOf(232L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].sv_id.constellation + "' != '" + 232 + "'", value.equals(BigInteger.valueOf( 232L ) ) ); } else { value = value.longValue(); expected = 232L; @@ -1182,9 +754,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].sv_id.satId + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].sv_id.satId + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -1192,9 +762,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].stec_coeff[0] + "' != '" + 12855 + "'", - value.equals(BigInteger.valueOf(12855L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].stec_coeff[0] + "' != '" + 12855 + "'", value.equals(BigInteger.valueOf( 12855L ) ) ); } else { value = value.longValue(); expected = 12855L; @@ -1202,9 +770,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].stec_coeff[1] + "' != '" + 1461 + "'", - value.equals(BigInteger.valueOf(1461L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].stec_coeff[1] + "' != '" + 1461 + "'", value.equals(BigInteger.valueOf( 1461L ) ) ); } else { value = value.longValue(); expected = 1461L; @@ -1212,9 +778,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].stec_coeff[2] + "' != '" + 20603 + "'", - value.equals(BigInteger.valueOf(20603L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].stec_coeff[2] + "' != '" + 20603 + "'", value.equals(BigInteger.valueOf( 20603L ) ) ); } else { value = value.longValue(); expected = 20603L; @@ -1222,9 +786,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].stec_coeff[3] + "' != '" + -3023 + "'", - value.equals(BigInteger.valueOf(-3023L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].stec_coeff[3] + "' != '" + -3023 + "'", value.equals(BigInteger.valueOf( -3023L ) ) ); } else { value = value.longValue(); expected = -3023L; @@ -1232,9 +794,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].stec_quality_indicator + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].stec_quality_indicator + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -1242,9 +802,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].sv_id.constellation + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].sv_id.constellation + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -1252,9 +810,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].sv_id.satId + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].sv_id.satId + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -1262,9 +818,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].stec_coeff[0] + "' != '" + -6492 + "'", - value.equals(BigInteger.valueOf(-6492L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].stec_coeff[0] + "' != '" + -6492 + "'", value.equals(BigInteger.valueOf( -6492L ) ) ); } else { value = value.longValue(); expected = -6492L; @@ -1272,9 +826,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].stec_coeff[1] + "' != '" + 16952 + "'", - value.equals(BigInteger.valueOf(16952L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].stec_coeff[1] + "' != '" + 16952 + "'", value.equals(BigInteger.valueOf( 16952L ) ) ); } else { value = value.longValue(); expected = 16952L; @@ -1282,9 +834,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].stec_coeff[2] + "' != '" + -22404 + "'", - value.equals(BigInteger.valueOf(-22404L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].stec_coeff[2] + "' != '" + -22404 + "'", value.equals(BigInteger.valueOf( -22404L ) ) ); } else { value = value.longValue(); expected = -22404L; @@ -1292,9 +842,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].stec_coeff[3] + "' != '" + -29893 + "'", - value.equals(BigInteger.valueOf(-29893L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].stec_coeff[3] + "' != '" + -29893 + "'", value.equals(BigInteger.valueOf( -29893L ) ) ); } else { value = value.longValue(); expected = -29893L; @@ -1302,9 +850,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].stec_quality_indicator + "' != '" + 125 + "'", - value.equals(BigInteger.valueOf(125L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].stec_quality_indicator + "' != '" + 125 + "'", value.equals(BigInteger.valueOf( 125L ) ) ); } else { value = value.longValue(); expected = 125L; @@ -1312,9 +858,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].sv_id.constellation + "' != '" + 188 + "'", - value.equals(BigInteger.valueOf(188L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].sv_id.constellation + "' != '" + 188 + "'", value.equals(BigInteger.valueOf( 188L ) ) ); } else { value = value.longValue(); expected = 188L; @@ -1322,9 +866,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].sv_id.satId + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].sv_id.satId + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -1332,9 +874,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].stec_coeff[0] + "' != '" + -10053 + "'", - value.equals(BigInteger.valueOf(-10053L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].stec_coeff[0] + "' != '" + -10053 + "'", value.equals(BigInteger.valueOf( -10053L ) ) ); } else { value = value.longValue(); expected = -10053L; @@ -1342,9 +882,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].stec_coeff[1] + "' != '" + -24897 + "'", - value.equals(BigInteger.valueOf(-24897L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].stec_coeff[1] + "' != '" + -24897 + "'", value.equals(BigInteger.valueOf( -24897L ) ) ); } else { value = value.longValue(); expected = -24897L; @@ -1352,9 +890,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].stec_coeff[2] + "' != '" + 23629 + "'", - value.equals(BigInteger.valueOf(23629L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].stec_coeff[2] + "' != '" + 23629 + "'", value.equals(BigInteger.valueOf( 23629L ) ) ); } else { value = value.longValue(); expected = 23629L; @@ -1362,9 +898,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].stec_coeff[3] + "' != '" + -710 + "'", - value.equals(BigInteger.valueOf(-710L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].stec_coeff[3] + "' != '" + -710 + "'", value.equals(BigInteger.valueOf( -710L ) ) ); } else { value = value.longValue(); expected = -710L; @@ -1372,9 +906,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].stec_quality_indicator + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].stec_quality_indicator + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -1382,9 +914,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].sv_id.constellation + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].sv_id.constellation + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -1392,9 +922,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].sv_id.satId + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].sv_id.satId + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -1402,9 +930,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].stec_coeff[0] + "' != '" + -26103 + "'", - value.equals(BigInteger.valueOf(-26103L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].stec_coeff[0] + "' != '" + -26103 + "'", value.equals(BigInteger.valueOf( -26103L ) ) ); } else { value = value.longValue(); expected = -26103L; @@ -1412,9 +938,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].stec_coeff[1] + "' != '" + -9539 + "'", - value.equals(BigInteger.valueOf(-9539L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].stec_coeff[1] + "' != '" + -9539 + "'", value.equals(BigInteger.valueOf( -9539L ) ) ); } else { value = value.longValue(); expected = -9539L; @@ -1422,9 +946,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].stec_coeff[2] + "' != '" + -11971 + "'", - value.equals(BigInteger.valueOf(-11971L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].stec_coeff[2] + "' != '" + -11971 + "'", value.equals(BigInteger.valueOf( -11971L ) ) ); } else { value = value.longValue(); expected = -11971L; @@ -1432,9 +954,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].stec_coeff[3] + "' != '" + 20993 + "'", - value.equals(BigInteger.valueOf(20993L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].stec_coeff[3] + "' != '" + 20993 + "'", value.equals(BigInteger.valueOf( 20993L ) ) ); } else { value = value.longValue(); expected = 20993L; @@ -1442,9 +962,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].stec_quality_indicator + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].stec_quality_indicator + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -1452,9 +970,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].sv_id.constellation + "' != '" + 150 + "'", - value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].sv_id.constellation + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -1462,9 +978,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].sv_id.satId + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].sv_id.satId + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -1472,9 +986,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].stec_coeff[0] + "' != '" + -18891 + "'", - value.equals(BigInteger.valueOf(-18891L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].stec_coeff[0] + "' != '" + -18891 + "'", value.equals(BigInteger.valueOf( -18891L ) ) ); } else { value = value.longValue(); expected = -18891L; @@ -1482,9 +994,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].stec_coeff[1] + "' != '" + -16272 + "'", - value.equals(BigInteger.valueOf(-16272L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].stec_coeff[1] + "' != '" + -16272 + "'", value.equals(BigInteger.valueOf( -16272L ) ) ); } else { value = value.longValue(); expected = -16272L; @@ -1492,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].stec_coeff[2] + "' != '" + -22578 + "'", - value.equals(BigInteger.valueOf(-22578L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].stec_coeff[2] + "' != '" + -22578 + "'", value.equals(BigInteger.valueOf( -22578L ) ) ); } else { value = value.longValue(); expected = -22578L; @@ -1502,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].stec_coeff[3] + "' != '" + -2915 + "'", - value.equals(BigInteger.valueOf(-2915L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].stec_coeff[3] + "' != '" + -2915 + "'", value.equals(BigInteger.valueOf( -2915L ) ) ); } else { value = value.longValue(); expected = -2915L; @@ -1512,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].stec_quality_indicator + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].stec_quality_indicator + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1522,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].sv_id.constellation + "' != '" + 196 + "'", - value.equals(BigInteger.valueOf(196L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].sv_id.constellation + "' != '" + 196 + "'", value.equals(BigInteger.valueOf( 196L ) ) ); } else { value = value.longValue(); expected = 196L; @@ -1532,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].sv_id.satId + "' != '" + 181 + "'", - value.equals(BigInteger.valueOf(181L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].sv_id.satId + "' != '" + 181 + "'", value.equals(BigInteger.valueOf( 181L ) ) ); } else { value = value.longValue(); expected = 181L; @@ -1542,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].stec_coeff[0] + "' != '" + 15833 + "'", - value.equals(BigInteger.valueOf(15833L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].stec_coeff[0] + "' != '" + 15833 + "'", value.equals(BigInteger.valueOf( 15833L ) ) ); } else { value = value.longValue(); expected = 15833L; @@ -1552,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].stec_coeff[1] + "' != '" + 24920 + "'", - value.equals(BigInteger.valueOf(24920L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].stec_coeff[1] + "' != '" + 24920 + "'", value.equals(BigInteger.valueOf( 24920L ) ) ); } else { value = value.longValue(); expected = 24920L; @@ -1562,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].stec_coeff[2] + "' != '" + -13879 + "'", - value.equals(BigInteger.valueOf(-13879L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].stec_coeff[2] + "' != '" + -13879 + "'", value.equals(BigInteger.valueOf( -13879L ) ) ); } else { value = value.longValue(); expected = -13879L; @@ -1572,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].stec_coeff[3] + "' != '" + -1206 + "'", - value.equals(BigInteger.valueOf(-1206L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].stec_coeff[3] + "' != '" + -1206 + "'", value.equals(BigInteger.valueOf( -1206L ) ) ); } else { value = value.longValue(); expected = -1206L; @@ -1582,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].stec_quality_indicator + "' != '" + 189 + "'", - value.equals(BigInteger.valueOf(189L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].stec_quality_indicator + "' != '" + 189 + "'", value.equals(BigInteger.valueOf( 189L ) ) ); } else { value = value.longValue(); expected = 189L; @@ -1592,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].sv_id.constellation + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].sv_id.constellation + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1602,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].sv_id.satId + "' != '" + 35 + "'", - value.equals(BigInteger.valueOf(35L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].sv_id.satId + "' != '" + 35 + "'", value.equals(BigInteger.valueOf( 35L ) ) ); } else { value = value.longValue(); expected = 35L; @@ -1612,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].stec_coeff[0] + "' != '" + 14008 + "'", - value.equals(BigInteger.valueOf(14008L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].stec_coeff[0] + "' != '" + 14008 + "'", value.equals(BigInteger.valueOf( 14008L ) ) ); } else { value = value.longValue(); expected = 14008L; @@ -1622,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].stec_coeff[1] + "' != '" + 18996 + "'", - value.equals(BigInteger.valueOf(18996L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].stec_coeff[1] + "' != '" + 18996 + "'", value.equals(BigInteger.valueOf( 18996L ) ) ); } else { value = value.longValue(); expected = 18996L; @@ -1632,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].stec_coeff[2] + "' != '" + 2798 + "'", - value.equals(BigInteger.valueOf(2798L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].stec_coeff[2] + "' != '" + 2798 + "'", value.equals(BigInteger.valueOf( 2798L ) ) ); } else { value = value.longValue(); expected = 2798L; @@ -1642,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].stec_coeff[3] + "' != '" + 5761 + "'", - value.equals(BigInteger.valueOf(5761L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].stec_coeff[3] + "' != '" + 5761 + "'", value.equals(BigInteger.valueOf( 5761L ) ) ); } else { value = value.longValue(); expected = 5761L; @@ -1652,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].stec_quality_indicator + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].stec_quality_indicator + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -1662,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].sv_id.constellation + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].sv_id.constellation + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -1672,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].sv_id.satId + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].sv_id.satId + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -1682,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].stec_coeff[0] + "' != '" + -25256 + "'", - value.equals(BigInteger.valueOf(-25256L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].stec_coeff[0] + "' != '" + -25256 + "'", value.equals(BigInteger.valueOf( -25256L ) ) ); } else { value = value.longValue(); expected = -25256L; @@ -1692,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].stec_coeff[1] + "' != '" + -15330 + "'", - value.equals(BigInteger.valueOf(-15330L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].stec_coeff[1] + "' != '" + -15330 + "'", value.equals(BigInteger.valueOf( -15330L ) ) ); } else { value = value.longValue(); expected = -15330L; @@ -1702,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].stec_coeff[2] + "' != '" + 6831 + "'", - value.equals(BigInteger.valueOf(6831L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].stec_coeff[2] + "' != '" + 6831 + "'", value.equals(BigInteger.valueOf( 6831L ) ) ); } else { value = value.longValue(); expected = 6831L; @@ -1712,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].stec_coeff[3] + "' != '" + 8780 + "'", - value.equals(BigInteger.valueOf(8780L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].stec_coeff[3] + "' != '" + 8780 + "'", value.equals(BigInteger.valueOf( 8780L ) ) ); } else { value = value.longValue(); expected = 8780L; @@ -1722,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].stec_quality_indicator + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].stec_quality_indicator + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -1732,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].sv_id.constellation + "' != '" + 226 + "'", - value.equals(BigInteger.valueOf(226L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].sv_id.constellation + "' != '" + 226 + "'", value.equals(BigInteger.valueOf( 226L ) ) ); } else { value = value.longValue(); expected = 226L; @@ -1742,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].sv_id.satId + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].sv_id.satId + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -1752,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].stec_coeff[0] + "' != '" + 3304 + "'", - value.equals(BigInteger.valueOf(3304L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].stec_coeff[0] + "' != '" + 3304 + "'", value.equals(BigInteger.valueOf( 3304L ) ) ); } else { value = value.longValue(); expected = 3304L; @@ -1762,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].stec_coeff[1] + "' != '" + -2893 + "'", - value.equals(BigInteger.valueOf(-2893L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].stec_coeff[1] + "' != '" + -2893 + "'", value.equals(BigInteger.valueOf( -2893L ) ) ); } else { value = value.longValue(); expected = -2893L; @@ -1772,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].stec_coeff[2] + "' != '" + -25841 + "'", - value.equals(BigInteger.valueOf(-25841L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].stec_coeff[2] + "' != '" + -25841 + "'", value.equals(BigInteger.valueOf( -25841L ) ) ); } else { value = value.longValue(); expected = -25841L; @@ -1782,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].stec_coeff[3] + "' != '" + -13628 + "'", - value.equals(BigInteger.valueOf(-13628L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].stec_coeff[3] + "' != '" + -13628 + "'", value.equals(BigInteger.valueOf( -13628L ) ) ); } else { value = value.longValue(); expected = -13628L; @@ -1792,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].stec_quality_indicator + "' != '" + 154 + "'", - value.equals(BigInteger.valueOf(154L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].stec_quality_indicator + "' != '" + 154 + "'", value.equals(BigInteger.valueOf( 154L ) ) ); } else { value = value.longValue(); expected = 154L; @@ -1802,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].sv_id.constellation + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].sv_id.constellation + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -1812,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].sv_id.satId + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].sv_id.satId + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1822,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[21].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[21].stec_coeff[0] + "' != '" + -10742 + "'", - value.equals(BigInteger.valueOf(-10742L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[21].stec_coeff[0] + "' != '" + -10742 + "'", value.equals(BigInteger.valueOf( -10742L ) ) ); } else { value = value.longValue(); expected = -10742L; @@ -1832,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[21].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[21].stec_coeff[1] + "' != '" + 10098 + "'", - value.equals(BigInteger.valueOf(10098L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[21].stec_coeff[1] + "' != '" + 10098 + "'", value.equals(BigInteger.valueOf( 10098L ) ) ); } else { value = value.longValue(); expected = 10098L; @@ -1842,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[21].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[21].stec_coeff[2] + "' != '" + 7413 + "'", - value.equals(BigInteger.valueOf(7413L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[21].stec_coeff[2] + "' != '" + 7413 + "'", value.equals(BigInteger.valueOf( 7413L ) ) ); } else { value = value.longValue(); expected = 7413L; @@ -1852,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[21].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[21].stec_coeff[3] + "' != '" + 17645 + "'", - value.equals(BigInteger.valueOf(17645L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[21].stec_coeff[3] + "' != '" + 17645 + "'", value.equals(BigInteger.valueOf( 17645L ) ) ); } else { value = value.longValue(); expected = 17645L; @@ -1862,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[21].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[21].stec_quality_indicator + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[21].stec_quality_indicator + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1872,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[21].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[21].sv_id.constellation + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[21].sv_id.constellation + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -1882,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[21].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[21].sv_id.satId + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[21].sv_id.satId + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionDepTest.java b/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionDepTest.java index 91ad2a210..44c67cf79 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionDepTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionDepTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrectionDep.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrectionDep.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrStecCorrectionDep; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrStecCorrectionDepTest { @@ -30,264 +34,15 @@ public class auto_check_sbp_ssr_MsgSsrStecCorrectionDepTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrStecCorrectionDepTest.test1"); - byte[] payload = - new byte[] { - (byte) 158, - (byte) 228, - (byte) 114, - (byte) 117, - (byte) 50, - (byte) 158, - (byte) 156, - (byte) 42, - (byte) 119, - (byte) 156, - (byte) 157, - (byte) 112, - (byte) 47, - (byte) 60, - (byte) 132, - (byte) 40, - (byte) 70, - (byte) 87, - (byte) 235, - (byte) 83, - (byte) 177, - (byte) 198, - (byte) 3, - (byte) 14, - (byte) 8, - (byte) 70, - (byte) 12, - (byte) 44, - (byte) 53, - (byte) 181, - (byte) 90, - (byte) 174, - (byte) 247, - (byte) 150, - (byte) 58, - (byte) 172, - (byte) 247, - (byte) 179, - (byte) 119, - (byte) 176, - (byte) 125, - (byte) 4, - (byte) 177, - (byte) 229, - (byte) 113, - (byte) 14, - (byte) 77, - (byte) 153, - (byte) 185, - (byte) 23, - (byte) 53, - (byte) 222, - (byte) 187, - (byte) 146, - (byte) 250, - (byte) 91, - (byte) 212, - (byte) 215, - (byte) 14, - (byte) 107, - (byte) 250, - (byte) 94, - (byte) 107, - (byte) 33, - (byte) 91, - (byte) 234, - (byte) 0, - (byte) 213, - (byte) 139, - (byte) 95, - (byte) 179, - (byte) 50, - (byte) 21, - (byte) 74, - (byte) 174, - (byte) 169, - (byte) 61, - (byte) 86, - (byte) 91, - (byte) 142, - (byte) 51, - (byte) 108, - (byte) 9, - (byte) 38, - (byte) 225, - (byte) 146, - (byte) 101, - (byte) 73, - (byte) 139, - (byte) 56, - (byte) 117, - (byte) 82, - (byte) 37, - (byte) 213, - (byte) 108, - (byte) 205, - (byte) 93, - (byte) 18, - (byte) 19, - (byte) 195, - (byte) 33, - (byte) 202, - (byte) 87, - (byte) 206, - (byte) 178, - (byte) 125, - (byte) 188, - (byte) 119, - (byte) 56, - (byte) 69, - (byte) 150, - (byte) 150, - (byte) 76, - (byte) 3, - (byte) 131, - (byte) 18, - (byte) 73, - (byte) 208, - (byte) 72, - (byte) 232, - (byte) 8, - (byte) 250, - (byte) 203, - (byte) 178, - (byte) 170, - (byte) 163, - (byte) 252, - (byte) 86, - (byte) 49, - (byte) 247, - (byte) 178, - (byte) 166, - (byte) 56, - (byte) 31, - (byte) 10, - (byte) 119, - (byte) 213, - (byte) 241, - (byte) 212, - (byte) 164, - (byte) 1, - (byte) 162, - (byte) 42, - (byte) 18, - (byte) 124, - (byte) 169, - (byte) 121, - (byte) 158, - (byte) 26, - (byte) 56, - (byte) 23, - (byte) 142, - (byte) 125, - (byte) 40, - (byte) 120, - (byte) 67, - (byte) 45, - (byte) 126, - (byte) 235, - (byte) 110, - (byte) 23, - (byte) 12, - (byte) 241, - (byte) 88, - (byte) 69, - (byte) 239, - (byte) 252, - (byte) 57, - (byte) 93, - (byte) 44, - (byte) 201, - (byte) 216, - (byte) 173, - (byte) 242, - (byte) 178, - (byte) 17, - (byte) 5, - (byte) 223, - (byte) 169, - (byte) 192, - (byte) 3, - (byte) 77, - (byte) 107, - (byte) 2, - (byte) 144, - (byte) 233, - (byte) 14, - (byte) 88, - (byte) 32, - (byte) 209, - (byte) 1, - (byte) 17, - (byte) 123, - (byte) 155, - (byte) 41, - (byte) 183, - (byte) 244, - (byte) 158, - (byte) 82, - (byte) 53, - (byte) 103, - (byte) 14, - (byte) 202, - (byte) 185, - (byte) 35, - (byte) 181, - (byte) 21, - (byte) 118, - (byte) 254, - (byte) 250, - (byte) 50, - (byte) 184, - (byte) 50, - (byte) 31, - (byte) 45, - (byte) 56, - (byte) 163, - (byte) 177, - (byte) 126, - (byte) 217, - (byte) 79, - (byte) 171, - (byte) 239, - (byte) 237, - (byte) 188, - (byte) 238, - (byte) 112, - (byte) 201, - (byte) 118, - (byte) 141, - (byte) 18, - (byte) 163, - (byte) 103, - (byte) 35, - (byte) 63, - (byte) 21, - (byte) 82, - (byte) 129, - (byte) 18, - (byte) 117, - (byte) 85, - (byte) 190, - (byte) 79, - (byte) 210, - (byte) 215, - }; - SBPMessage sbp = new SBPMessage(0x97cc, 0x5fb, payload); - MsgSsrStecCorrectionDep msg = new MsgSsrStecCorrectionDep(sbp); + byte[] payload = new byte[] {(byte)158,(byte)228,(byte)114,(byte)117,(byte)50,(byte)158,(byte)156,(byte)42,(byte)119,(byte)156,(byte)157,(byte)112,(byte)47,(byte)60,(byte)132,(byte)40,(byte)70,(byte)87,(byte)235,(byte)83,(byte)177,(byte)198,(byte)3,(byte)14,(byte)8,(byte)70,(byte)12,(byte)44,(byte)53,(byte)181,(byte)90,(byte)174,(byte)247,(byte)150,(byte)58,(byte)172,(byte)247,(byte)179,(byte)119,(byte)176,(byte)125,(byte)4,(byte)177,(byte)229,(byte)113,(byte)14,(byte)77,(byte)153,(byte)185,(byte)23,(byte)53,(byte)222,(byte)187,(byte)146,(byte)250,(byte)91,(byte)212,(byte)215,(byte)14,(byte)107,(byte)250,(byte)94,(byte)107,(byte)33,(byte)91,(byte)234,(byte)0,(byte)213,(byte)139,(byte)95,(byte)179,(byte)50,(byte)21,(byte)74,(byte)174,(byte)169,(byte)61,(byte)86,(byte)91,(byte)142,(byte)51,(byte)108,(byte)9,(byte)38,(byte)225,(byte)146,(byte)101,(byte)73,(byte)139,(byte)56,(byte)117,(byte)82,(byte)37,(byte)213,(byte)108,(byte)205,(byte)93,(byte)18,(byte)19,(byte)195,(byte)33,(byte)202,(byte)87,(byte)206,(byte)178,(byte)125,(byte)188,(byte)119,(byte)56,(byte)69,(byte)150,(byte)150,(byte)76,(byte)3,(byte)131,(byte)18,(byte)73,(byte)208,(byte)72,(byte)232,(byte)8,(byte)250,(byte)203,(byte)178,(byte)170,(byte)163,(byte)252,(byte)86,(byte)49,(byte)247,(byte)178,(byte)166,(byte)56,(byte)31,(byte)10,(byte)119,(byte)213,(byte)241,(byte)212,(byte)164,(byte)1,(byte)162,(byte)42,(byte)18,(byte)124,(byte)169,(byte)121,(byte)158,(byte)26,(byte)56,(byte)23,(byte)142,(byte)125,(byte)40,(byte)120,(byte)67,(byte)45,(byte)126,(byte)235,(byte)110,(byte)23,(byte)12,(byte)241,(byte)88,(byte)69,(byte)239,(byte)252,(byte)57,(byte)93,(byte)44,(byte)201,(byte)216,(byte)173,(byte)242,(byte)178,(byte)17,(byte)5,(byte)223,(byte)169,(byte)192,(byte)3,(byte)77,(byte)107,(byte)2,(byte)144,(byte)233,(byte)14,(byte)88,(byte)32,(byte)209,(byte)1,(byte)17,(byte)123,(byte)155,(byte)41,(byte)183,(byte)244,(byte)158,(byte)82,(byte)53,(byte)103,(byte)14,(byte)202,(byte)185,(byte)35,(byte)181,(byte)21,(byte)118,(byte)254,(byte)250,(byte)50,(byte)184,(byte)50,(byte)31,(byte)45,(byte)56,(byte)163,(byte)177,(byte)126,(byte)217,(byte)79,(byte)171,(byte)239,(byte)237,(byte)188,(byte)238,(byte)112,(byte)201,(byte)118,(byte)141,(byte)18,(byte)163,(byte)103,(byte)35,(byte)63,(byte)21,(byte)82,(byte)129,(byte)18,(byte)117,(byte)85,(byte)190,(byte)79,(byte)210,(byte)215, }; + SBPMessage sbp = new SBPMessage( 0x97cc, 0x5fb, payload ); + MsgSsrStecCorrectionDep msg = new MsgSsrStecCorrectionDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.header.iod_atmo; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.iod_atmo + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.header.iod_atmo + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -295,9 +50,7 @@ public void test1() throws Throwable { } value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -305,9 +58,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -315,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tile_id + "' != '" + 30066 + "'", - value.equals(BigInteger.valueOf(30066L))); + org.junit.Assert.assertTrue("'" + msg.header.tile_id + "' != '" + 30066 + "'", value.equals(BigInteger.valueOf( 30066L ) ) ); } else { value = value.longValue(); expected = 30066L; @@ -325,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.tile_set_id + "' != '" + 58526 + "'", - value.equals(BigInteger.valueOf(58526L))); + org.junit.Assert.assertTrue("'" + msg.header.tile_set_id + "' != '" + 58526 + "'", value.equals(BigInteger.valueOf( 58526L ) ) ); } else { value = value.longValue(); expected = 58526L; @@ -335,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.tow + "' != '" + 714907186 + "'", - value.equals(BigInteger.valueOf(714907186L))); + org.junit.Assert.assertTrue("'" + msg.header.time.tow + "' != '" + 714907186 + "'", value.equals(BigInteger.valueOf( 714907186L ) ) ); } else { value = value.longValue(); expected = 714907186L; @@ -345,9 +90,7 @@ public void test1() throws Throwable { } value = msg.header.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.wn + "' != '" + 40055 + "'", - value.equals(BigInteger.valueOf(40055L))); + org.junit.Assert.assertTrue("'" + msg.header.time.wn + "' != '" + 40055 + "'", value.equals(BigInteger.valueOf( 40055L ) ) ); } else { value = value.longValue(); expected = 40055L; @@ -355,9 +98,7 @@ public void test1() throws Throwable { } value = msg.header.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.update_interval + "' != '" + 47 + "'", - value.equals(BigInteger.valueOf(47L))); + org.junit.Assert.assertTrue("'" + msg.header.update_interval + "' != '" + 47 + "'", value.equals(BigInteger.valueOf( 47L ) ) ); } else { value = value.longValue(); expected = 47L; @@ -365,9 +106,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_coeff[0] + "' != '" + -5289 + "'", - value.equals(BigInteger.valueOf(-5289L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_coeff[0] + "' != '" + -5289 + "'", value.equals(BigInteger.valueOf( -5289L ) ) ); } else { value = value.longValue(); expected = -5289L; @@ -375,9 +114,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_coeff[1] + "' != '" + -20141 + "'", - value.equals(BigInteger.valueOf(-20141L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_coeff[1] + "' != '" + -20141 + "'", value.equals(BigInteger.valueOf( -20141L ) ) ); } else { value = value.longValue(); expected = -20141L; @@ -385,9 +122,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_coeff[2] + "' != '" + 966 + "'", - value.equals(BigInteger.valueOf(966L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_coeff[2] + "' != '" + 966 + "'", value.equals(BigInteger.valueOf( 966L ) ) ); } else { value = value.longValue(); expected = 966L; @@ -395,9 +130,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_coeff[3] + "' != '" + 2062 + "'", - value.equals(BigInteger.valueOf(2062L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_coeff[3] + "' != '" + 2062 + "'", value.equals(BigInteger.valueOf( 2062L ) ) ); } else { value = value.longValue(); expected = 2062L; @@ -405,9 +138,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_quality_indicator + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_quality_indicator + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -415,9 +146,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].sv_id.constellation + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].sv_id.constellation + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -425,9 +154,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].sv_id.satId + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].sv_id.satId + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -435,9 +162,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_coeff[0] + "' != '" + -19147 + "'", - value.equals(BigInteger.valueOf(-19147L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_coeff[0] + "' != '" + -19147 + "'", value.equals(BigInteger.valueOf( -19147L ) ) ); } else { value = value.longValue(); expected = -19147L; @@ -445,9 +170,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_coeff[1] + "' != '" + -20902 + "'", - value.equals(BigInteger.valueOf(-20902L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_coeff[1] + "' != '" + -20902 + "'", value.equals(BigInteger.valueOf( -20902L ) ) ); } else { value = value.longValue(); expected = -20902L; @@ -455,9 +178,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_coeff[2] + "' != '" + -26889 + "'", - value.equals(BigInteger.valueOf(-26889L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_coeff[2] + "' != '" + -26889 + "'", value.equals(BigInteger.valueOf( -26889L ) ) ); } else { value = value.longValue(); expected = -26889L; @@ -465,9 +186,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_coeff[3] + "' != '" + -21446 + "'", - value.equals(BigInteger.valueOf(-21446L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_coeff[3] + "' != '" + -21446 + "'", value.equals(BigInteger.valueOf( -21446L ) ) ); } else { value = value.longValue(); expected = -21446L; @@ -475,9 +194,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_quality_indicator + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_quality_indicator + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -485,9 +202,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].sv_id.constellation + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].sv_id.constellation + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -495,9 +210,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].sv_id.satId + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].sv_id.satId + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -505,9 +218,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].stec_coeff[0] + "' != '" + 32176 + "'", - value.equals(BigInteger.valueOf(32176L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].stec_coeff[0] + "' != '" + 32176 + "'", value.equals(BigInteger.valueOf( 32176L ) ) ); } else { value = value.longValue(); expected = 32176L; @@ -515,9 +226,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].stec_coeff[1] + "' != '" + -20220 + "'", - value.equals(BigInteger.valueOf(-20220L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].stec_coeff[1] + "' != '" + -20220 + "'", value.equals(BigInteger.valueOf( -20220L ) ) ); } else { value = value.longValue(); expected = -20220L; @@ -525,9 +234,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].stec_coeff[2] + "' != '" + 29157 + "'", - value.equals(BigInteger.valueOf(29157L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].stec_coeff[2] + "' != '" + 29157 + "'", value.equals(BigInteger.valueOf( 29157L ) ) ); } else { value = value.longValue(); expected = 29157L; @@ -535,9 +242,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].stec_coeff[3] + "' != '" + 19726 + "'", - value.equals(BigInteger.valueOf(19726L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].stec_coeff[3] + "' != '" + 19726 + "'", value.equals(BigInteger.valueOf( 19726L ) ) ); } else { value = value.longValue(); expected = 19726L; @@ -545,9 +250,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].stec_quality_indicator + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].stec_quality_indicator + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -555,9 +258,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].sv_id.constellation + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].sv_id.constellation + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -565,9 +266,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[2].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[2].sv_id.satId + "' != '" + 247 + "'", - value.equals(BigInteger.valueOf(247L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[2].sv_id.satId + "' != '" + 247 + "'", value.equals(BigInteger.valueOf( 247L ) ) ); } else { value = value.longValue(); expected = 247L; @@ -575,9 +274,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].stec_coeff[0] + "' != '" + -8651 + "'", - value.equals(BigInteger.valueOf(-8651L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].stec_coeff[0] + "' != '" + -8651 + "'", value.equals(BigInteger.valueOf( -8651L ) ) ); } else { value = value.longValue(); expected = -8651L; @@ -585,9 +282,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].stec_coeff[1] + "' != '" + -27973 + "'", - value.equals(BigInteger.valueOf(-27973L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].stec_coeff[1] + "' != '" + -27973 + "'", value.equals(BigInteger.valueOf( -27973L ) ) ); } else { value = value.longValue(); expected = -27973L; @@ -595,9 +290,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].stec_coeff[2] + "' != '" + 23546 + "'", - value.equals(BigInteger.valueOf(23546L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].stec_coeff[2] + "' != '" + 23546 + "'", value.equals(BigInteger.valueOf( 23546L ) ) ); } else { value = value.longValue(); expected = 23546L; @@ -605,9 +298,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].stec_coeff[3] + "' != '" + -10284 + "'", - value.equals(BigInteger.valueOf(-10284L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].stec_coeff[3] + "' != '" + -10284 + "'", value.equals(BigInteger.valueOf( -10284L ) ) ); } else { value = value.longValue(); expected = -10284L; @@ -615,9 +306,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].stec_quality_indicator + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].stec_quality_indicator + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -625,9 +314,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].sv_id.constellation + "' != '" + 185 + "'", - value.equals(BigInteger.valueOf(185L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].sv_id.constellation + "' != '" + 185 + "'", value.equals(BigInteger.valueOf( 185L ) ) ); } else { value = value.longValue(); expected = 185L; @@ -635,9 +322,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[3].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[3].sv_id.satId + "' != '" + 153 + "'", - value.equals(BigInteger.valueOf(153L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[3].sv_id.satId + "' != '" + 153 + "'", value.equals(BigInteger.valueOf( 153L ) ) ); } else { value = value.longValue(); expected = 153L; @@ -645,9 +330,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].stec_coeff[0] + "' != '" + 27486 + "'", - value.equals(BigInteger.valueOf(27486L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].stec_coeff[0] + "' != '" + 27486 + "'", value.equals(BigInteger.valueOf( 27486L ) ) ); } else { value = value.longValue(); expected = 27486L; @@ -655,9 +338,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].stec_coeff[1] + "' != '" + 23329 + "'", - value.equals(BigInteger.valueOf(23329L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].stec_coeff[1] + "' != '" + 23329 + "'", value.equals(BigInteger.valueOf( 23329L ) ) ); } else { value = value.longValue(); expected = 23329L; @@ -665,9 +346,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].stec_coeff[2] + "' != '" + 234 + "'", - value.equals(BigInteger.valueOf(234L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].stec_coeff[2] + "' != '" + 234 + "'", value.equals(BigInteger.valueOf( 234L ) ) ); } else { value = value.longValue(); expected = 234L; @@ -675,9 +354,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].stec_coeff[3] + "' != '" + -29739 + "'", - value.equals(BigInteger.valueOf(-29739L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].stec_coeff[3] + "' != '" + -29739 + "'", value.equals(BigInteger.valueOf( -29739L ) ) ); } else { value = value.longValue(); expected = -29739L; @@ -685,9 +362,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].stec_quality_indicator + "' != '" + 250 + "'", - value.equals(BigInteger.valueOf(250L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].stec_quality_indicator + "' != '" + 250 + "'", value.equals(BigInteger.valueOf( 250L ) ) ); } else { value = value.longValue(); expected = 250L; @@ -695,9 +370,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].sv_id.constellation + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].sv_id.constellation + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -705,9 +378,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[4].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[4].sv_id.satId + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[4].sv_id.satId + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -715,9 +386,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].stec_coeff[0] + "' != '" + 18965 + "'", - value.equals(BigInteger.valueOf(18965L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].stec_coeff[0] + "' != '" + 18965 + "'", value.equals(BigInteger.valueOf( 18965L ) ) ); } else { value = value.longValue(); expected = 18965L; @@ -725,9 +394,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].stec_coeff[1] + "' != '" + -22098 + "'", - value.equals(BigInteger.valueOf(-22098L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].stec_coeff[1] + "' != '" + -22098 + "'", value.equals(BigInteger.valueOf( -22098L ) ) ); } else { value = value.longValue(); expected = -22098L; @@ -735,9 +402,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].stec_coeff[2] + "' != '" + 22077 + "'", - value.equals(BigInteger.valueOf(22077L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].stec_coeff[2] + "' != '" + 22077 + "'", value.equals(BigInteger.valueOf( 22077L ) ) ); } else { value = value.longValue(); expected = 22077L; @@ -745,9 +410,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].stec_coeff[3] + "' != '" + -29093 + "'", - value.equals(BigInteger.valueOf(-29093L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].stec_coeff[3] + "' != '" + -29093 + "'", value.equals(BigInteger.valueOf( -29093L ) ) ); } else { value = value.longValue(); expected = -29093L; @@ -755,9 +418,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].stec_quality_indicator + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].stec_quality_indicator + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -765,9 +426,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].sv_id.constellation + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].sv_id.constellation + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -775,9 +434,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[5].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[5].sv_id.satId + "' != '" + 95 + "'", - value.equals(BigInteger.valueOf(95L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[5].sv_id.satId + "' != '" + 95 + "'", value.equals(BigInteger.valueOf( 95L ) ) ); } else { value = value.longValue(); expected = 95L; @@ -785,9 +442,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].stec_coeff[0] + "' != '" + -7898 + "'", - value.equals(BigInteger.valueOf(-7898L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].stec_coeff[0] + "' != '" + -7898 + "'", value.equals(BigInteger.valueOf( -7898L ) ) ); } else { value = value.longValue(); expected = -7898L; @@ -795,9 +450,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].stec_coeff[1] + "' != '" + 26002 + "'", - value.equals(BigInteger.valueOf(26002L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].stec_coeff[1] + "' != '" + 26002 + "'", value.equals(BigInteger.valueOf( 26002L ) ) ); } else { value = value.longValue(); expected = 26002L; @@ -805,9 +458,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].stec_coeff[2] + "' != '" + -29879 + "'", - value.equals(BigInteger.valueOf(-29879L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].stec_coeff[2] + "' != '" + -29879 + "'", value.equals(BigInteger.valueOf( -29879L ) ) ); } else { value = value.longValue(); expected = -29879L; @@ -815,9 +466,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].stec_coeff[3] + "' != '" + 30008 + "'", - value.equals(BigInteger.valueOf(30008L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].stec_coeff[3] + "' != '" + 30008 + "'", value.equals(BigInteger.valueOf( 30008L ) ) ); } else { value = value.longValue(); expected = 30008L; @@ -825,9 +474,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].stec_quality_indicator + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].stec_quality_indicator + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -835,9 +482,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].sv_id.constellation + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].sv_id.constellation + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -845,9 +490,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[6].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[6].sv_id.satId + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[6].sv_id.satId + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -855,9 +498,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].stec_coeff[0] + "' != '" + -12948 + "'", - value.equals(BigInteger.valueOf(-12948L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].stec_coeff[0] + "' != '" + -12948 + "'", value.equals(BigInteger.valueOf( -12948L ) ) ); } else { value = value.longValue(); expected = -12948L; @@ -865,9 +506,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].stec_coeff[1] + "' != '" + 4701 + "'", - value.equals(BigInteger.valueOf(4701L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].stec_coeff[1] + "' != '" + 4701 + "'", value.equals(BigInteger.valueOf( 4701L ) ) ); } else { value = value.longValue(); expected = 4701L; @@ -875,9 +514,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].stec_coeff[2] + "' != '" + -15597 + "'", - value.equals(BigInteger.valueOf(-15597L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].stec_coeff[2] + "' != '" + -15597 + "'", value.equals(BigInteger.valueOf( -15597L ) ) ); } else { value = value.longValue(); expected = -15597L; @@ -885,9 +522,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].stec_coeff[3] + "' != '" + -13791 + "'", - value.equals(BigInteger.valueOf(-13791L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].stec_coeff[3] + "' != '" + -13791 + "'", value.equals(BigInteger.valueOf( -13791L ) ) ); } else { value = value.longValue(); expected = -13791L; @@ -895,9 +530,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].stec_quality_indicator + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].stec_quality_indicator + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -905,9 +538,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].sv_id.constellation + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].sv_id.constellation + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -915,9 +546,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[7].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[7].sv_id.satId + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[7].sv_id.satId + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -925,9 +554,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].stec_coeff[0] + "' != '" + -17283 + "'", - value.equals(BigInteger.valueOf(-17283L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].stec_coeff[0] + "' != '" + -17283 + "'", value.equals(BigInteger.valueOf( -17283L ) ) ); } else { value = value.longValue(); expected = -17283L; @@ -935,9 +562,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].stec_coeff[1] + "' != '" + 14455 + "'", - value.equals(BigInteger.valueOf(14455L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].stec_coeff[1] + "' != '" + 14455 + "'", value.equals(BigInteger.valueOf( 14455L ) ) ); } else { value = value.longValue(); expected = 14455L; @@ -945,9 +570,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].stec_coeff[2] + "' != '" + -27067 + "'", - value.equals(BigInteger.valueOf(-27067L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].stec_coeff[2] + "' != '" + -27067 + "'", value.equals(BigInteger.valueOf( -27067L ) ) ); } else { value = value.longValue(); expected = -27067L; @@ -955,9 +578,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].stec_coeff[3] + "' != '" + 19606 + "'", - value.equals(BigInteger.valueOf(19606L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].stec_coeff[3] + "' != '" + 19606 + "'", value.equals(BigInteger.valueOf( 19606L ) ) ); } else { value = value.longValue(); expected = 19606L; @@ -965,9 +586,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].stec_quality_indicator + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].stec_quality_indicator + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -975,9 +594,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].sv_id.constellation + "' != '" + 206 + "'", - value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].sv_id.constellation + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; @@ -985,9 +602,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[8].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[8].sv_id.satId + "' != '" + 87 + "'", - value.equals(BigInteger.valueOf(87L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[8].sv_id.satId + "' != '" + 87 + "'", value.equals(BigInteger.valueOf( 87L ) ) ); } else { value = value.longValue(); expected = 87L; @@ -995,9 +610,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].stec_coeff[0] + "' != '" + -12215 + "'", - value.equals(BigInteger.valueOf(-12215L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].stec_coeff[0] + "' != '" + -12215 + "'", value.equals(BigInteger.valueOf( -12215L ) ) ); } else { value = value.longValue(); expected = -12215L; @@ -1005,9 +618,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].stec_coeff[1] + "' != '" + -6072 + "'", - value.equals(BigInteger.valueOf(-6072L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].stec_coeff[1] + "' != '" + -6072 + "'", value.equals(BigInteger.valueOf( -6072L ) ) ); } else { value = value.longValue(); expected = -6072L; @@ -1015,9 +626,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].stec_coeff[2] + "' != '" + -1528 + "'", - value.equals(BigInteger.valueOf(-1528L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].stec_coeff[2] + "' != '" + -1528 + "'", value.equals(BigInteger.valueOf( -1528L ) ) ); } else { value = value.longValue(); expected = -1528L; @@ -1025,9 +634,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].stec_coeff[3] + "' != '" + -19765 + "'", - value.equals(BigInteger.valueOf(-19765L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].stec_coeff[3] + "' != '" + -19765 + "'", value.equals(BigInteger.valueOf( -19765L ) ) ); } else { value = value.longValue(); expected = -19765L; @@ -1035,9 +642,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].stec_quality_indicator + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].stec_quality_indicator + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -1045,9 +650,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].sv_id.constellation + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].sv_id.constellation + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -1055,9 +658,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[9].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[9].sv_id.satId + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[9].sv_id.satId + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1065,9 +666,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].stec_coeff[0] + "' != '" + 12630 + "'", - value.equals(BigInteger.valueOf(12630L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].stec_coeff[0] + "' != '" + 12630 + "'", value.equals(BigInteger.valueOf( 12630L ) ) ); } else { value = value.longValue(); expected = 12630L; @@ -1075,9 +674,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].stec_coeff[1] + "' != '" + -19721 + "'", - value.equals(BigInteger.valueOf(-19721L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].stec_coeff[1] + "' != '" + -19721 + "'", value.equals(BigInteger.valueOf( -19721L ) ) ); } else { value = value.longValue(); expected = -19721L; @@ -1085,9 +682,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].stec_coeff[2] + "' != '" + 14502 + "'", - value.equals(BigInteger.valueOf(14502L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].stec_coeff[2] + "' != '" + 14502 + "'", value.equals(BigInteger.valueOf( 14502L ) ) ); } else { value = value.longValue(); expected = 14502L; @@ -1095,9 +690,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].stec_coeff[3] + "' != '" + 2591 + "'", - value.equals(BigInteger.valueOf(2591L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].stec_coeff[3] + "' != '" + 2591 + "'", value.equals(BigInteger.valueOf( 2591L ) ) ); } else { value = value.longValue(); expected = 2591L; @@ -1105,9 +698,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].stec_quality_indicator + "' != '" + 252 + "'", - value.equals(BigInteger.valueOf(252L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].stec_quality_indicator + "' != '" + 252 + "'", value.equals(BigInteger.valueOf( 252L ) ) ); } else { value = value.longValue(); expected = 252L; @@ -1115,9 +706,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].sv_id.constellation + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].sv_id.constellation + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -1125,9 +714,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[10].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[10].sv_id.satId + "' != '" + 170 + "'", - value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[10].sv_id.satId + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -1135,9 +722,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].stec_coeff[0] + "' != '" + -23340 + "'", - value.equals(BigInteger.valueOf(-23340L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].stec_coeff[0] + "' != '" + -23340 + "'", value.equals(BigInteger.valueOf( -23340L ) ) ); } else { value = value.longValue(); expected = -23340L; @@ -1145,9 +730,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].stec_coeff[1] + "' != '" + -24063 + "'", - value.equals(BigInteger.valueOf(-24063L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].stec_coeff[1] + "' != '" + -24063 + "'", value.equals(BigInteger.valueOf( -24063L ) ) ); } else { value = value.longValue(); expected = -24063L; @@ -1155,9 +738,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].stec_coeff[2] + "' != '" + 4650 + "'", - value.equals(BigInteger.valueOf(4650L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].stec_coeff[2] + "' != '" + 4650 + "'", value.equals(BigInteger.valueOf( 4650L ) ) ); } else { value = value.longValue(); expected = 4650L; @@ -1165,9 +746,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].stec_coeff[3] + "' != '" + -22148 + "'", - value.equals(BigInteger.valueOf(-22148L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].stec_coeff[3] + "' != '" + -22148 + "'", value.equals(BigInteger.valueOf( -22148L ) ) ); } else { value = value.longValue(); expected = -22148L; @@ -1175,9 +754,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].stec_quality_indicator + "' != '" + 241 + "'", - value.equals(BigInteger.valueOf(241L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].stec_quality_indicator + "' != '" + 241 + "'", value.equals(BigInteger.valueOf( 241L ) ) ); } else { value = value.longValue(); expected = 241L; @@ -1185,9 +762,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].sv_id.constellation + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].sv_id.constellation + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -1195,9 +770,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[11].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[11].sv_id.satId + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[11].sv_id.satId + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -1205,9 +778,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].stec_coeff[0] + "' != '" + 5944 + "'", - value.equals(BigInteger.valueOf(5944L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].stec_coeff[0] + "' != '" + 5944 + "'", value.equals(BigInteger.valueOf( 5944L ) ) ); } else { value = value.longValue(); expected = 5944L; @@ -1215,9 +786,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].stec_coeff[1] + "' != '" + 32142 + "'", - value.equals(BigInteger.valueOf(32142L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].stec_coeff[1] + "' != '" + 32142 + "'", value.equals(BigInteger.valueOf( 32142L ) ) ); } else { value = value.longValue(); expected = 32142L; @@ -1225,9 +794,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].stec_coeff[2] + "' != '" + 30760 + "'", - value.equals(BigInteger.valueOf(30760L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].stec_coeff[2] + "' != '" + 30760 + "'", value.equals(BigInteger.valueOf( 30760L ) ) ); } else { value = value.longValue(); expected = 30760L; @@ -1235,9 +802,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].stec_coeff[3] + "' != '" + 11587 + "'", - value.equals(BigInteger.valueOf(11587L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].stec_coeff[3] + "' != '" + 11587 + "'", value.equals(BigInteger.valueOf( 11587L ) ) ); } else { value = value.longValue(); expected = 11587L; @@ -1245,9 +810,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].stec_quality_indicator + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].stec_quality_indicator + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -1255,9 +818,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].sv_id.constellation + "' != '" + 158 + "'", - value.equals(BigInteger.valueOf(158L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].sv_id.constellation + "' != '" + 158 + "'", value.equals(BigInteger.valueOf( 158L ) ) ); } else { value = value.longValue(); expected = 158L; @@ -1265,9 +826,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[12].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[12].sv_id.satId + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[12].sv_id.satId + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -1275,9 +834,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].stec_coeff[0] + "' != '" + 3095 + "'", - value.equals(BigInteger.valueOf(3095L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].stec_coeff[0] + "' != '" + 3095 + "'", value.equals(BigInteger.valueOf( 3095L ) ) ); } else { value = value.longValue(); expected = 3095L; @@ -1285,9 +842,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].stec_coeff[1] + "' != '" + 22769 + "'", - value.equals(BigInteger.valueOf(22769L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].stec_coeff[1] + "' != '" + 22769 + "'", value.equals(BigInteger.valueOf( 22769L ) ) ); } else { value = value.longValue(); expected = 22769L; @@ -1295,9 +850,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].stec_coeff[2] + "' != '" + -4283 + "'", - value.equals(BigInteger.valueOf(-4283L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].stec_coeff[2] + "' != '" + -4283 + "'", value.equals(BigInteger.valueOf( -4283L ) ) ); } else { value = value.longValue(); expected = -4283L; @@ -1305,9 +858,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].stec_coeff[3] + "' != '" + 14844 + "'", - value.equals(BigInteger.valueOf(14844L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].stec_coeff[3] + "' != '" + 14844 + "'", value.equals(BigInteger.valueOf( 14844L ) ) ); } else { value = value.longValue(); expected = 14844L; @@ -1315,9 +866,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].stec_quality_indicator + "' != '" + 110 + "'", - value.equals(BigInteger.valueOf(110L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].stec_quality_indicator + "' != '" + 110 + "'", value.equals(BigInteger.valueOf( 110L ) ) ); } else { value = value.longValue(); expected = 110L; @@ -1325,9 +874,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].sv_id.constellation + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].sv_id.constellation + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -1335,9 +882,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[13].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[13].sv_id.satId + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[13].sv_id.satId + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -1345,9 +890,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].stec_coeff[0] + "' != '" + -21032 + "'", - value.equals(BigInteger.valueOf(-21032L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].stec_coeff[0] + "' != '" + -21032 + "'", value.equals(BigInteger.valueOf( -21032L ) ) ); } else { value = value.longValue(); expected = -21032L; @@ -1355,9 +898,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].stec_coeff[1] + "' != '" + -19726 + "'", - value.equals(BigInteger.valueOf(-19726L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].stec_coeff[1] + "' != '" + -19726 + "'", value.equals(BigInteger.valueOf( -19726L ) ) ); } else { value = value.longValue(); expected = -19726L; @@ -1365,9 +906,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].stec_coeff[2] + "' != '" + 1297 + "'", - value.equals(BigInteger.valueOf(1297L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].stec_coeff[2] + "' != '" + 1297 + "'", value.equals(BigInteger.valueOf( 1297L ) ) ); } else { value = value.longValue(); expected = 1297L; @@ -1375,9 +914,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].stec_coeff[3] + "' != '" + -22049 + "'", - value.equals(BigInteger.valueOf(-22049L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].stec_coeff[3] + "' != '" + -22049 + "'", value.equals(BigInteger.valueOf( -22049L ) ) ); } else { value = value.longValue(); expected = -22049L; @@ -1385,9 +922,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].stec_quality_indicator + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].stec_quality_indicator + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -1395,9 +930,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].sv_id.constellation + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].sv_id.constellation + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -1405,9 +938,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[14].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[14].sv_id.satId + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[14].sv_id.satId + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -1415,9 +946,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].stec_coeff[0] + "' != '" + 619 + "'", - value.equals(BigInteger.valueOf(619L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].stec_coeff[0] + "' != '" + 619 + "'", value.equals(BigInteger.valueOf( 619L ) ) ); } else { value = value.longValue(); expected = 619L; @@ -1425,9 +954,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].stec_coeff[1] + "' != '" + -5744 + "'", - value.equals(BigInteger.valueOf(-5744L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].stec_coeff[1] + "' != '" + -5744 + "'", value.equals(BigInteger.valueOf( -5744L ) ) ); } else { value = value.longValue(); expected = -5744L; @@ -1435,9 +962,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].stec_coeff[2] + "' != '" + 22542 + "'", - value.equals(BigInteger.valueOf(22542L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].stec_coeff[2] + "' != '" + 22542 + "'", value.equals(BigInteger.valueOf( 22542L ) ) ); } else { value = value.longValue(); expected = 22542L; @@ -1445,9 +970,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].stec_coeff[3] + "' != '" + -12000 + "'", - value.equals(BigInteger.valueOf(-12000L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].stec_coeff[3] + "' != '" + -12000 + "'", value.equals(BigInteger.valueOf( -12000L ) ) ); } else { value = value.longValue(); expected = -12000L; @@ -1455,9 +978,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].stec_quality_indicator + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].stec_quality_indicator + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -1465,9 +986,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].sv_id.constellation + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].sv_id.constellation + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1475,9 +994,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[15].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[15].sv_id.satId + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[15].sv_id.satId + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -1485,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].stec_coeff[0] + "' != '" + 10651 + "'", - value.equals(BigInteger.valueOf(10651L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].stec_coeff[0] + "' != '" + 10651 + "'", value.equals(BigInteger.valueOf( 10651L ) ) ); } else { value = value.longValue(); expected = 10651L; @@ -1495,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].stec_coeff[1] + "' != '" + -2889 + "'", - value.equals(BigInteger.valueOf(-2889L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].stec_coeff[1] + "' != '" + -2889 + "'", value.equals(BigInteger.valueOf( -2889L ) ) ); } else { value = value.longValue(); expected = -2889L; @@ -1505,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].stec_coeff[2] + "' != '" + 21150 + "'", - value.equals(BigInteger.valueOf(21150L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].stec_coeff[2] + "' != '" + 21150 + "'", value.equals(BigInteger.valueOf( 21150L ) ) ); } else { value = value.longValue(); expected = 21150L; @@ -1515,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].stec_coeff[3] + "' != '" + 26421 + "'", - value.equals(BigInteger.valueOf(26421L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].stec_coeff[3] + "' != '" + 26421 + "'", value.equals(BigInteger.valueOf( 26421L ) ) ); } else { value = value.longValue(); expected = 26421L; @@ -1525,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].stec_quality_indicator + "' != '" + 123 + "'", - value.equals(BigInteger.valueOf(123L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].stec_quality_indicator + "' != '" + 123 + "'", value.equals(BigInteger.valueOf( 123L ) ) ); } else { value = value.longValue(); expected = 123L; @@ -1535,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].sv_id.constellation + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].sv_id.constellation + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -1545,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[16].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[16].sv_id.satId + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[16].sv_id.satId + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1555,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].stec_coeff[0] + "' != '" + -19165 + "'", - value.equals(BigInteger.valueOf(-19165L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].stec_coeff[0] + "' != '" + -19165 + "'", value.equals(BigInteger.valueOf( -19165L ) ) ); } else { value = value.longValue(); expected = -19165L; @@ -1565,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].stec_coeff[1] + "' != '" + 30229 + "'", - value.equals(BigInteger.valueOf(30229L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].stec_coeff[1] + "' != '" + 30229 + "'", value.equals(BigInteger.valueOf( 30229L ) ) ); } else { value = value.longValue(); expected = 30229L; @@ -1575,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].stec_coeff[2] + "' != '" + -1282 + "'", - value.equals(BigInteger.valueOf(-1282L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].stec_coeff[2] + "' != '" + -1282 + "'", value.equals(BigInteger.valueOf( -1282L ) ) ); } else { value = value.longValue(); expected = -1282L; @@ -1585,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].stec_coeff[3] + "' != '" + -18382 + "'", - value.equals(BigInteger.valueOf(-18382L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].stec_coeff[3] + "' != '" + -18382 + "'", value.equals(BigInteger.valueOf( -18382L ) ) ); } else { value = value.longValue(); expected = -18382L; @@ -1595,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].stec_quality_indicator + "' != '" + 185 + "'", - value.equals(BigInteger.valueOf(185L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].stec_quality_indicator + "' != '" + 185 + "'", value.equals(BigInteger.valueOf( 185L ) ) ); } else { value = value.longValue(); expected = 185L; @@ -1605,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].sv_id.constellation + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].sv_id.constellation + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -1615,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[17].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[17].sv_id.satId + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[17].sv_id.satId + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -1625,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].stec_coeff[0] + "' != '" + -23752 + "'", - value.equals(BigInteger.valueOf(-23752L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].stec_coeff[0] + "' != '" + -23752 + "'", value.equals(BigInteger.valueOf( -23752L ) ) ); } else { value = value.longValue(); expected = -23752L; @@ -1635,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].stec_coeff[1] + "' != '" + 32433 + "'", - value.equals(BigInteger.valueOf(32433L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].stec_coeff[1] + "' != '" + 32433 + "'", value.equals(BigInteger.valueOf( 32433L ) ) ); } else { value = value.longValue(); expected = 32433L; @@ -1645,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].stec_coeff[2] + "' != '" + 20441 + "'", - value.equals(BigInteger.valueOf(20441L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].stec_coeff[2] + "' != '" + 20441 + "'", value.equals(BigInteger.valueOf( 20441L ) ) ); } else { value = value.longValue(); expected = 20441L; @@ -1655,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].stec_coeff[3] + "' != '" + -4181 + "'", - value.equals(BigInteger.valueOf(-4181L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].stec_coeff[3] + "' != '" + -4181 + "'", value.equals(BigInteger.valueOf( -4181L ) ) ); } else { value = value.longValue(); expected = -4181L; @@ -1665,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].stec_quality_indicator + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].stec_quality_indicator + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -1675,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].sv_id.constellation + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].sv_id.constellation + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -1685,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[18].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[18].sv_id.satId + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[18].sv_id.satId + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -1695,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].stec_coeff[0] + "' != '" + -13968 + "'", - value.equals(BigInteger.valueOf(-13968L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].stec_coeff[0] + "' != '" + -13968 + "'", value.equals(BigInteger.valueOf( -13968L ) ) ); } else { value = value.longValue(); expected = -13968L; @@ -1705,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].stec_coeff[1] + "' != '" + -29322 + "'", - value.equals(BigInteger.valueOf(-29322L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].stec_coeff[1] + "' != '" + -29322 + "'", value.equals(BigInteger.valueOf( -29322L ) ) ); } else { value = value.longValue(); expected = -29322L; @@ -1715,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].stec_coeff[2] + "' != '" + -23790 + "'", - value.equals(BigInteger.valueOf(-23790L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].stec_coeff[2] + "' != '" + -23790 + "'", value.equals(BigInteger.valueOf( -23790L ) ) ); } else { value = value.longValue(); expected = -23790L; @@ -1725,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].stec_coeff[3] + "' != '" + 9063 + "'", - value.equals(BigInteger.valueOf(9063L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].stec_coeff[3] + "' != '" + 9063 + "'", value.equals(BigInteger.valueOf( 9063L ) ) ); } else { value = value.longValue(); expected = 9063L; @@ -1735,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].stec_quality_indicator + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].stec_quality_indicator + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -1745,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].sv_id.constellation + "' != '" + 188 + "'", - value.equals(BigInteger.valueOf(188L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].sv_id.constellation + "' != '" + 188 + "'", value.equals(BigInteger.valueOf( 188L ) ) ); } else { value = value.longValue(); expected = 188L; @@ -1755,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[19].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[19].sv_id.satId + "' != '" + 237 + "'", - value.equals(BigInteger.valueOf(237L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[19].sv_id.satId + "' != '" + 237 + "'", value.equals(BigInteger.valueOf( 237L ) ) ); } else { value = value.longValue(); expected = 237L; @@ -1765,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].stec_coeff[0] + "' != '" + 4737 + "'", - value.equals(BigInteger.valueOf(4737L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].stec_coeff[0] + "' != '" + 4737 + "'", value.equals(BigInteger.valueOf( 4737L ) ) ); } else { value = value.longValue(); expected = 4737L; @@ -1775,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].stec_coeff[1] + "' != '" + 21877 + "'", - value.equals(BigInteger.valueOf(21877L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].stec_coeff[1] + "' != '" + 21877 + "'", value.equals(BigInteger.valueOf( 21877L ) ) ); } else { value = value.longValue(); expected = 21877L; @@ -1785,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].stec_coeff[2] + "' != '" + 20414 + "'", - value.equals(BigInteger.valueOf(20414L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].stec_coeff[2] + "' != '" + 20414 + "'", value.equals(BigInteger.valueOf( 20414L ) ) ); } else { value = value.longValue(); expected = 20414L; @@ -1795,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].stec_coeff[3] + "' != '" + -10286 + "'", - value.equals(BigInteger.valueOf(-10286L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].stec_coeff[3] + "' != '" + -10286 + "'", value.equals(BigInteger.valueOf( -10286L ) ) ); } else { value = value.longValue(); expected = -10286L; @@ -1805,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].stec_quality_indicator + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].stec_quality_indicator + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -1815,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].sv_id.constellation + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].sv_id.constellation + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -1825,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[20].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[20].sv_id.satId + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[20].sv_id.satId + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionTest.java b/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionTest.java index a7b67690e..287461e93 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrStecCorrectionTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrection.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrStecCorrection.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrStecCorrection; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrStecCorrectionTest { @@ -27,26 +32,17 @@ public class auto_check_sbp_ssr_MsgSsrStecCorrectionTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrStecCorrectionTest.test1"); - byte[] payload = - new byte[] { - (byte) 180, (byte) 0, (byte) 0, (byte) 0, (byte) 3, (byte) 0, (byte) 1, - (byte) 1, (byte) 10, (byte) 0, (byte) 15, (byte) 1, (byte) 0, (byte) 10, - (byte) 0, (byte) 2, (byte) 1, (byte) 1, (byte) 1, (byte) 63, (byte) 0, - (byte) 62, (byte) 0, (byte) 61, (byte) 0, (byte) 60, (byte) 0, (byte) 31, - (byte) 15, (byte) 5, (byte) 63, (byte) 0, (byte) 64, (byte) 0, (byte) 65, - (byte) 0, (byte) 66, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x05FD, payload); - MsgSsrStecCorrection msg = new MsgSsrStecCorrection(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrStecCorrectionTest.test1"); + byte[] payload = new byte[] {(byte)180,(byte)0,(byte)0,(byte)0,(byte)3,(byte)0,(byte)1,(byte)1,(byte)10,(byte)0,(byte)15,(byte)1,(byte)0,(byte)10,(byte)0,(byte)2,(byte)1,(byte)1,(byte)1,(byte)63,(byte)0,(byte)62,(byte)0,(byte)61,(byte)0,(byte)60,(byte)0,(byte)31,(byte)15,(byte)5,(byte)63,(byte)0,(byte)64,(byte)0,(byte)65,(byte)0,(byte)66,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x05FD, payload ); + MsgSsrStecCorrection msg = new MsgSsrStecCorrection( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.header.num_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.num_msgs + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.header.num_msgs + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -54,9 +50,7 @@ public void test1() throws Throwable { } value = msg.header.seq_num; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.seq_num + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.header.seq_num + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -64,9 +58,7 @@ public void test1() throws Throwable { } value = msg.header.sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.sol_id + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.header.sol_id + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -74,9 +66,7 @@ public void test1() throws Throwable { } value = msg.header.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.tow + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.header.time.tow + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -84,9 +74,7 @@ public void test1() throws Throwable { } value = msg.header.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.time.wn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.header.time.wn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -94,9 +82,7 @@ public void test1() throws Throwable { } value = msg.header.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.header.update_interval + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.header.update_interval + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -104,8 +90,7 @@ public void test1() throws Throwable { } value = msg.n_sats; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_sats + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.n_sats + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -113,9 +98,7 @@ public void test1() throws Throwable { } value = msg.ssr_iod_atmo; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ssr_iod_atmo + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.ssr_iod_atmo + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -123,9 +106,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_coeff[0] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_coeff[0] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -133,9 +114,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_coeff[1] + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_coeff[1] + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -143,9 +122,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_coeff[2] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_coeff[2] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -153,9 +130,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_coeff[3] + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_coeff[3] + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -163,9 +138,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].stec_quality_indicator + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].stec_quality_indicator + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -173,9 +146,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].sv_id.constellation + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].sv_id.constellation + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -183,9 +154,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[0].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[0].sv_id.satId + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[0].sv_id.satId + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -193,9 +162,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_coeff[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_coeff[0] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_coeff[0] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -203,9 +170,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_coeff[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_coeff[1] + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_coeff[1] + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -213,9 +178,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_coeff[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_coeff[2] + "' != '" + 65 + "'", - value.equals(BigInteger.valueOf(65L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_coeff[2] + "' != '" + 65 + "'", value.equals(BigInteger.valueOf( 65L ) ) ); } else { value = value.longValue(); expected = 65L; @@ -223,9 +186,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_coeff[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_coeff[3] + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_coeff[3] + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -233,9 +194,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].stec_quality_indicator; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].stec_quality_indicator + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].stec_quality_indicator + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -243,9 +202,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].sv_id.constellation; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].sv_id.constellation + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].sv_id.constellation + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -253,9 +210,7 @@ public void test1() throws Throwable { } value = msg.stec_sat_list[1].sv_id.satId; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.stec_sat_list[1].sv_id.satId + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.stec_sat_list[1].sv_id.satId + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -263,8 +218,7 @@ public void test1() throws Throwable { } value = msg.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_id + "' != '" + 10 + "'", value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.tile_id + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -272,9 +226,7 @@ public void test1() throws Throwable { } value = msg.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_set_id + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.tile_set_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionDepATest.java b/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionDepATest.java index da71a978a..b93af10b0 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionDepATest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinitionDepA.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinitionDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrTileDefinitionDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrTileDefinitionDepATest { @@ -30,43 +34,15 @@ public class auto_check_sbp_ssr_MsgSsrTileDefinitionDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrTileDefinitionDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 57, - (byte) 190, - (byte) 178, - (byte) 247, - (byte) 8, - (byte) 185, - (byte) 9, - (byte) 181, - (byte) 162, - (byte) 240, - (byte) 65, - (byte) 19, - (byte) 255, - (byte) 143, - (byte) 21, - (byte) 191, - (byte) 239, - (byte) 205, - (byte) 171, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x85c8, 0x5f6, payload); - MsgSsrTileDefinitionDepA msg = new MsgSsrTileDefinitionDepA(sbp); + byte[] payload = new byte[] {(byte)57,(byte)190,(byte)178,(byte)247,(byte)8,(byte)185,(byte)9,(byte)181,(byte)162,(byte)240,(byte)65,(byte)19,(byte)255,(byte)143,(byte)21,(byte)191,(byte)239,(byte)205,(byte)171,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x85c8, 0x5f6, payload ); + MsgSsrTileDefinitionDepA msg = new MsgSsrTileDefinitionDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.bitmask; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.bitmask + "' != '" + 11259375 + "'", - value.equals(BigInteger.valueOf(11259375L))); + org.junit.Assert.assertTrue("'" + msg.bitmask + "' != '" + 11259375 + "'", value.equals(BigInteger.valueOf( 11259375L ) ) ); } else { value = value.longValue(); expected = 11259375L; @@ -74,9 +50,7 @@ public void test1() throws Throwable { } value = msg.cols; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cols + "' != '" + 48917 + "'", - value.equals(BigInteger.valueOf(48917L))); + org.junit.Assert.assertTrue("'" + msg.cols + "' != '" + 48917 + "'", value.equals(BigInteger.valueOf( 48917L ) ) ); } else { value = value.longValue(); expected = 48917L; @@ -84,9 +58,7 @@ public void test1() throws Throwable { } value = msg.corner_nw_lat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corner_nw_lat + "' != '" + -18168 + "'", - value.equals(BigInteger.valueOf(-18168L))); + org.junit.Assert.assertTrue("'" + msg.corner_nw_lat + "' != '" + -18168 + "'", value.equals(BigInteger.valueOf( -18168L ) ) ); } else { value = value.longValue(); expected = -18168L; @@ -94,9 +66,7 @@ public void test1() throws Throwable { } value = msg.corner_nw_lon; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corner_nw_lon + "' != '" + -19191 + "'", - value.equals(BigInteger.valueOf(-19191L))); + org.junit.Assert.assertTrue("'" + msg.corner_nw_lon + "' != '" + -19191 + "'", value.equals(BigInteger.valueOf( -19191L ) ) ); } else { value = value.longValue(); expected = -19191L; @@ -104,9 +74,7 @@ public void test1() throws Throwable { } value = msg.rows; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rows + "' != '" + 36863 + "'", - value.equals(BigInteger.valueOf(36863L))); + org.junit.Assert.assertTrue("'" + msg.rows + "' != '" + 36863 + "'", value.equals(BigInteger.valueOf( 36863L ) ) ); } else { value = value.longValue(); expected = 36863L; @@ -114,9 +82,7 @@ public void test1() throws Throwable { } value = msg.spacing_lat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.spacing_lat + "' != '" + 61602 + "'", - value.equals(BigInteger.valueOf(61602L))); + org.junit.Assert.assertTrue("'" + msg.spacing_lat + "' != '" + 61602 + "'", value.equals(BigInteger.valueOf( 61602L ) ) ); } else { value = value.longValue(); expected = 61602L; @@ -124,9 +90,7 @@ public void test1() throws Throwable { } value = msg.spacing_lon; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.spacing_lon + "' != '" + 4929 + "'", - value.equals(BigInteger.valueOf(4929L))); + org.junit.Assert.assertTrue("'" + msg.spacing_lon + "' != '" + 4929 + "'", value.equals(BigInteger.valueOf( 4929L ) ) ); } else { value = value.longValue(); expected = 4929L; @@ -134,9 +98,7 @@ public void test1() throws Throwable { } value = msg.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_id + "' != '" + 63410 + "'", - value.equals(BigInteger.valueOf(63410L))); + org.junit.Assert.assertTrue("'" + msg.tile_id + "' != '" + 63410 + "'", value.equals(BigInteger.valueOf( 63410L ) ) ); } else { value = value.longValue(); expected = 63410L; @@ -144,9 +106,7 @@ public void test1() throws Throwable { } value = msg.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_set_id + "' != '" + 48697 + "'", - value.equals(BigInteger.valueOf(48697L))); + org.junit.Assert.assertTrue("'" + msg.tile_set_id + "' != '" + 48697 + "'", value.equals(BigInteger.valueOf( 48697L ) ) ); } else { value = value.longValue(); expected = 48697L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionDepBTest.java b/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionDepBTest.java index d6d15280b..eb6071b98 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionDepBTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionDepBTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinitionDepB.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinitionDepB.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrTileDefinitionDepB; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrTileDefinitionDepBTest { @@ -30,44 +34,15 @@ public class auto_check_sbp_ssr_MsgSsrTileDefinitionDepBTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrTileDefinitionDepBTest.test1"); - byte[] payload = - new byte[] { - (byte) 31, - (byte) 0, - (byte) 1, - (byte) 0, - (byte) 2, - (byte) 0, - (byte) 4, - (byte) 0, - (byte) 8, - (byte) 0, - (byte) 16, - (byte) 0, - (byte) 32, - (byte) 0, - (byte) 64, - (byte) 0, - (byte) 128, - (byte) 210, - (byte) 2, - (byte) 150, - (byte) 73, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x0042, 0x05F7, payload); - MsgSsrTileDefinitionDepB msg = new MsgSsrTileDefinitionDepB(sbp); + byte[] payload = new byte[] {(byte)31,(byte)0,(byte)1,(byte)0,(byte)2,(byte)0,(byte)4,(byte)0,(byte)8,(byte)0,(byte)16,(byte)0,(byte)32,(byte)0,(byte)64,(byte)0,(byte)128,(byte)210,(byte)2,(byte)150,(byte)73,(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x0042, 0x05F7, payload ); + MsgSsrTileDefinitionDepB msg = new MsgSsrTileDefinitionDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.bitmask; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.bitmask + "' != '" + 1234567890 + "'", - value.equals(BigInteger.valueOf(1234567890L))); + org.junit.Assert.assertTrue("'" + msg.bitmask + "' != '" + 1234567890 + "'", value.equals(BigInteger.valueOf( 1234567890L ) ) ); } else { value = value.longValue(); expected = 1234567890L; @@ -75,9 +50,7 @@ public void test1() throws Throwable { } value = msg.cols; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cols + "' != '" + 32768 + "'", - value.equals(BigInteger.valueOf(32768L))); + org.junit.Assert.assertTrue("'" + msg.cols + "' != '" + 32768 + "'", value.equals(BigInteger.valueOf( 32768L ) ) ); } else { value = value.longValue(); expected = 32768L; @@ -85,9 +58,7 @@ public void test1() throws Throwable { } value = msg.corner_nw_lat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corner_nw_lat + "' != '" + 1024 + "'", - value.equals(BigInteger.valueOf(1024L))); + org.junit.Assert.assertTrue("'" + msg.corner_nw_lat + "' != '" + 1024 + "'", value.equals(BigInteger.valueOf( 1024L ) ) ); } else { value = value.longValue(); expected = 1024L; @@ -95,9 +66,7 @@ public void test1() throws Throwable { } value = msg.corner_nw_lon; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corner_nw_lon + "' != '" + 2048 + "'", - value.equals(BigInteger.valueOf(2048L))); + org.junit.Assert.assertTrue("'" + msg.corner_nw_lon + "' != '" + 2048 + "'", value.equals(BigInteger.valueOf( 2048L ) ) ); } else { value = value.longValue(); expected = 2048L; @@ -105,9 +74,7 @@ public void test1() throws Throwable { } value = msg.rows; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rows + "' != '" + 16384 + "'", - value.equals(BigInteger.valueOf(16384L))); + org.junit.Assert.assertTrue("'" + msg.rows + "' != '" + 16384 + "'", value.equals(BigInteger.valueOf( 16384L ) ) ); } else { value = value.longValue(); expected = 16384L; @@ -115,9 +82,7 @@ public void test1() throws Throwable { } value = msg.spacing_lat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.spacing_lat + "' != '" + 4096 + "'", - value.equals(BigInteger.valueOf(4096L))); + org.junit.Assert.assertTrue("'" + msg.spacing_lat + "' != '" + 4096 + "'", value.equals(BigInteger.valueOf( 4096L ) ) ); } else { value = value.longValue(); expected = 4096L; @@ -125,9 +90,7 @@ public void test1() throws Throwable { } value = msg.spacing_lon; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.spacing_lon + "' != '" + 8192 + "'", - value.equals(BigInteger.valueOf(8192L))); + org.junit.Assert.assertTrue("'" + msg.spacing_lon + "' != '" + 8192 + "'", value.equals(BigInteger.valueOf( 8192L ) ) ); } else { value = value.longValue(); expected = 8192L; @@ -135,9 +98,7 @@ public void test1() throws Throwable { } value = msg.ssr_sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ssr_sol_id + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.ssr_sol_id + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -145,9 +106,7 @@ public void test1() throws Throwable { } value = msg.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_id + "' != '" + 512 + "'", - value.equals(BigInteger.valueOf(512L))); + org.junit.Assert.assertTrue("'" + msg.tile_id + "' != '" + 512 + "'", value.equals(BigInteger.valueOf( 512L ) ) ); } else { value = value.longValue(); expected = 512L; @@ -155,9 +114,7 @@ public void test1() throws Throwable { } value = msg.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_set_id + "' != '" + 256 + "'", - value.equals(BigInteger.valueOf(256L))); + org.junit.Assert.assertTrue("'" + msg.tile_set_id + "' != '" + 256 + "'", value.equals(BigInteger.valueOf( 256L ) ) ); } else { value = value.longValue(); expected = 256L; diff --git a/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionTest.java b/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionTest.java index aba4d8ef3..b99f30b4c 100644 --- a/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionTest.java +++ b/java/test/auto_check_sbp_ssr_MsgSsrTileDefinitionTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinition.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_MsgSsrTileDefinition.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.ssr.MsgSsrTileDefinition; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_ssr_MsgSsrTileDefinitionTest { @@ -27,25 +32,17 @@ public class auto_check_sbp_ssr_MsgSsrTileDefinitionTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrTileDefinitionTest.test1"); - byte[] payload = - new byte[] { - (byte) 127, (byte) 58, (byte) 9, (byte) 0, (byte) 174, (byte) 8, (byte) 1, - (byte) 2, (byte) 3, (byte) 4, (byte) 0, (byte) 5, (byte) 0, (byte) 186, - (byte) 28, (byte) 59, (byte) 167, (byte) 100, (byte) 0, (byte) 100, (byte) 0, - (byte) 6, (byte) 0, (byte) 6, (byte) 0, (byte) 210, (byte) 2, (byte) 150, - (byte) 73, (byte) 0, (byte) 0, (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x0, 0x5F8, payload); - MsgSsrTileDefinition msg = new MsgSsrTileDefinition(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_ssr_MsgSsrTileDefinitionTest.test1"); + byte[] payload = new byte[] {(byte)127,(byte)58,(byte)9,(byte)0,(byte)174,(byte)8,(byte)1,(byte)2,(byte)3,(byte)4,(byte)0,(byte)5,(byte)0,(byte)186,(byte)28,(byte)59,(byte)167,(byte)100,(byte)0,(byte)100,(byte)0,(byte)6,(byte)0,(byte)6,(byte)0,(byte)210,(byte)2,(byte)150,(byte)73,(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x0, 0x5F8, payload ); + MsgSsrTileDefinition msg = new MsgSsrTileDefinition( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.bitmask; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.bitmask + "' != '" + 1234567890 + "'", - value.equals(BigInteger.valueOf(1234567890L))); + org.junit.Assert.assertTrue("'" + msg.bitmask + "' != '" + 1234567890 + "'", value.equals(BigInteger.valueOf( 1234567890L ) ) ); } else { value = value.longValue(); expected = 1234567890L; @@ -53,8 +50,7 @@ public void test1() throws Throwable { } value = msg.cols; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cols + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.cols + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -62,9 +58,7 @@ public void test1() throws Throwable { } value = msg.corner_nw_lat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corner_nw_lat + "' != '" + 7354 + "'", - value.equals(BigInteger.valueOf(7354L))); + org.junit.Assert.assertTrue("'" + msg.corner_nw_lat + "' != '" + 7354 + "'", value.equals(BigInteger.valueOf( 7354L ) ) ); } else { value = value.longValue(); expected = 7354L; @@ -72,9 +66,7 @@ public void test1() throws Throwable { } value = msg.corner_nw_lon; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corner_nw_lon + "' != '" + -22725 + "'", - value.equals(BigInteger.valueOf(-22725L))); + org.junit.Assert.assertTrue("'" + msg.corner_nw_lon + "' != '" + -22725 + "'", value.equals(BigInteger.valueOf( -22725L ) ) ); } else { value = value.longValue(); expected = -22725L; @@ -82,8 +74,7 @@ public void test1() throws Throwable { } value = msg.iod_atmo; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.iod_atmo + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.iod_atmo + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -91,8 +82,7 @@ public void test1() throws Throwable { } value = msg.rows; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.rows + "' != '" + 6 + "'", value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.rows + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -100,8 +90,7 @@ public void test1() throws Throwable { } value = msg.sol_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sol_id + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.sol_id + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -109,9 +98,7 @@ public void test1() throws Throwable { } value = msg.spacing_lat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.spacing_lat + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.spacing_lat + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -119,9 +106,7 @@ public void test1() throws Throwable { } value = msg.spacing_lon; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.spacing_lon + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.spacing_lon + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -129,8 +114,7 @@ public void test1() throws Throwable { } value = msg.tile_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_id + "' != '" + 5 + "'", value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.tile_id + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -138,9 +122,7 @@ public void test1() throws Throwable { } value = msg.tile_set_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tile_set_id + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.tile_set_id + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -148,9 +130,7 @@ public void test1() throws Throwable { } value = msg.time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time.tow + "' != '" + 604799 + "'", - value.equals(BigInteger.valueOf(604799L))); + org.junit.Assert.assertTrue("'" + msg.time.tow + "' != '" + 604799 + "'", value.equals(BigInteger.valueOf( 604799L ) ) ); } else { value = value.longValue(); expected = 604799L; @@ -158,9 +138,7 @@ public void test1() throws Throwable { } value = msg.time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time.wn + "' != '" + 2222 + "'", - value.equals(BigInteger.valueOf(2222L))); + org.junit.Assert.assertTrue("'" + msg.time.wn + "' != '" + 2222 + "'", value.equals(BigInteger.valueOf( 2222L ) ) ); } else { value = value.longValue(); expected = 2222L; @@ -168,9 +146,7 @@ public void test1() throws Throwable { } value = msg.update_interval; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.update_interval + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.update_interval + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; diff --git a/java/test/auto_check_sbp_ssr_ssr_structsTest.java b/java/test/auto_check_sbp_ssr_ssr_structsTest.java index b48d9a6a3..20e470d80 100644 --- a/java/test/auto_check_sbp_ssr_ssr_structsTest.java +++ b/java/test/auto_check_sbp_ssr_ssr_structsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,10 +9,19 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_ssr_structs.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/ssr/test_ssr_structs.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; + +import org.json.JSONObject; + +import com.swiftnav.sbp.SBPMessage; + public class auto_check_sbp_ssr_ssr_structsTest { diff --git a/java/test/auto_check_sbp_system_MsgCsacTelemetryLabelsTest.java b/java/test/auto_check_sbp_system_MsgCsacTelemetryLabelsTest.java index 447690c4e..356c1271e 100644 --- a/java/test/auto_check_sbp_system_MsgCsacTelemetryLabelsTest.java +++ b/java/test/auto_check_sbp_system_MsgCsacTelemetryLabelsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/system/test_MsgCsacTelemetryLabels.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgCsacTelemetryLabels.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgCsacTelemetryLabels; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgCsacTelemetryLabelsTest { @@ -30,26 +34,21 @@ public class auto_check_sbp_system_MsgCsacTelemetryLabelsTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgCsacTelemetryLabelsTest.test1"); - byte[] payload = - new byte[] { - (byte) 186, (byte) 115, (byte) 111, (byte) 109, (byte) 101, (byte) 32, - (byte) 108, (byte) 97, (byte) 98, (byte) 101, (byte) 108, (byte) 115, - }; - SBPMessage sbp = new SBPMessage(0xc85b, 0xff05, payload); - MsgCsacTelemetryLabels msg = new MsgCsacTelemetryLabels(sbp); + byte[] payload = new byte[] {(byte)186,(byte)115,(byte)111,(byte)109,(byte)101,(byte)32,(byte)108,(byte)97,(byte)98,(byte)101,(byte)108,(byte)115, }; + SBPMessage sbp = new SBPMessage( 0xc85b, 0xff05, payload ); + MsgCsacTelemetryLabels msg = new MsgCsacTelemetryLabels( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.id + "' != '" + 186 + "'", value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.id + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; org.junit.Assert.assertEquals(value, expected); } - org.junit.Assert.assertEquals(msg.telemetry_labels, "some labels"); + org.junit.Assert.assertEquals(msg.telemetry_labels, "some labels" ); org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); } diff --git a/java/test/auto_check_sbp_system_MsgCsacTelemetryTest.java b/java/test/auto_check_sbp_system_MsgCsacTelemetryTest.java index 4b375e2f1..b25e7abdc 100644 --- a/java/test/auto_check_sbp_system_MsgCsacTelemetryTest.java +++ b/java/test/auto_check_sbp_system_MsgCsacTelemetryTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgCsacTelemetry.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgCsacTelemetry.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgCsacTelemetry; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgCsacTelemetryTest { @@ -27,35 +32,23 @@ public class auto_check_sbp_system_MsgCsacTelemetryTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgCsacTelemetryTest.test1"); - byte[] payload = - new byte[] { - (byte) 105, - (byte) 115, - (byte) 111, - (byte) 109, - (byte) 101, - (byte) 32, - (byte) 100, - (byte) 97, - (byte) 116, - (byte) 97, - }; - SBPMessage sbp = new SBPMessage(0xa9f4, 0xff04, payload); - MsgCsacTelemetry msg = new MsgCsacTelemetry(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgCsacTelemetryTest.test1"); + byte[] payload = new byte[] {(byte)105,(byte)115,(byte)111,(byte)109,(byte)101,(byte)32,(byte)100,(byte)97,(byte)116,(byte)97, }; + SBPMessage sbp = new SBPMessage( 0xa9f4, 0xff04, payload ); + MsgCsacTelemetry msg = new MsgCsacTelemetry( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.id + "' != '" + 105 + "'", value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.id + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; org.junit.Assert.assertEquals(value, expected); } - org.junit.Assert.assertEquals(msg.telemetry, "some data"); + org.junit.Assert.assertEquals(msg.telemetry, "some data" ); org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); } diff --git a/java/test/auto_check_sbp_system_MsgDgnssStatusTest.java b/java/test/auto_check_sbp_system_MsgDgnssStatusTest.java index 7157232be..86f97d870 100644 --- a/java/test/auto_check_sbp_system_MsgDgnssStatusTest.java +++ b/java/test/auto_check_sbp_system_MsgDgnssStatusTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgDgnssStatus.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgDgnssStatus.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgDgnssStatus; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgDgnssStatusTest { @@ -27,30 +32,17 @@ public class auto_check_sbp_system_MsgDgnssStatusTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgDgnssStatusTest.test1"); - byte[] payload = - new byte[] { - (byte) 0, - (byte) 50, - (byte) 0, - (byte) 12, - (byte) 83, - (byte) 107, - (byte) 121, - (byte) 108, - (byte) 97, - (byte) 114, - (byte) 107, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xff02, payload); - MsgDgnssStatus msg = new MsgDgnssStatus(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgDgnssStatusTest.test1"); + byte[] payload = new byte[] {(byte)0,(byte)50,(byte)0,(byte)12,(byte)83,(byte)107,(byte)121,(byte)108,(byte)97,(byte)114,(byte)107, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xff02, payload ); + MsgDgnssStatus msg = new MsgDgnssStatus( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -58,8 +50,7 @@ public void test1() throws Throwable { } value = msg.latency; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.latency + "' != '" + 50 + "'", value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.latency + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -67,15 +58,13 @@ public void test1() throws Throwable { } value = msg.num_signals; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.num_signals + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.num_signals + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; org.junit.Assert.assertEquals(value, expected); } - org.junit.Assert.assertEquals(msg.source, "Skylark"); + org.junit.Assert.assertEquals(msg.source, "Skylark" ); org.junit.Assert.assertNotEquals("", msg.getFriendlyName()); } diff --git a/java/test/auto_check_sbp_system_MsgGnssTimeOffsetTest.java b/java/test/auto_check_sbp_system_MsgGnssTimeOffsetTest.java index 61fad1768..584796122 100644 --- a/java/test/auto_check_sbp_system_MsgGnssTimeOffsetTest.java +++ b/java/test/auto_check_sbp_system_MsgGnssTimeOffsetTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgGnssTimeOffset.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgGnssTimeOffset.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgGnssTimeOffset; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgGnssTimeOffsetTest { @@ -27,28 +32,17 @@ public class auto_check_sbp_system_MsgGnssTimeOffsetTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgGnssTimeOffsetTest.test1"); - byte[] payload = - new byte[] { - (byte) 9, - (byte) 58, - (byte) 82, - (byte) 83, - (byte) 9, - (byte) 103, - (byte) 22, - (byte) 37, - (byte) 221, - }; - SBPMessage sbp = new SBPMessage(0x0f16, 0xff07, payload); - MsgGnssTimeOffset msg = new MsgGnssTimeOffset(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgGnssTimeOffsetTest.test1"); + byte[] payload = new byte[] {(byte)9,(byte)58,(byte)82,(byte)83,(byte)9,(byte)103,(byte)22,(byte)37,(byte)221, }; + SBPMessage sbp = new SBPMessage( 0x0f16, 0xff07, payload ); + MsgGnssTimeOffset msg = new MsgGnssTimeOffset( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 221 + "'", value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -56,9 +50,7 @@ public void test1() throws Throwable { } value = msg.microseconds; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.microseconds + "' != '" + 9494 + "'", - value.equals(BigInteger.valueOf(9494L))); + org.junit.Assert.assertTrue("'" + msg.microseconds + "' != '" + 9494 + "'", value.equals(BigInteger.valueOf( 9494L ) ) ); } else { value = value.longValue(); expected = 9494L; @@ -66,9 +58,7 @@ public void test1() throws Throwable { } value = msg.milliseconds; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.milliseconds + "' != '" + 1728664402 + "'", - value.equals(BigInteger.valueOf(1728664402L))); + org.junit.Assert.assertTrue("'" + msg.milliseconds + "' != '" + 1728664402 + "'", value.equals(BigInteger.valueOf( 1728664402L ) ) ); } else { value = value.longValue(); expected = 1728664402L; @@ -76,9 +66,7 @@ public void test1() throws Throwable { } value = msg.weeks; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.weeks + "' != '" + 14857 + "'", - value.equals(BigInteger.valueOf(14857L))); + org.junit.Assert.assertTrue("'" + msg.weeks + "' != '" + 14857 + "'", value.equals(BigInteger.valueOf( 14857L ) ) ); } else { value = value.longValue(); expected = 14857L; diff --git a/java/test/auto_check_sbp_system_MsgGroupMetaTest.java b/java/test/auto_check_sbp_system_MsgGroupMetaTest.java index 573e43046..79741e73f 100644 --- a/java/test/auto_check_sbp_system_MsgGroupMetaTest.java +++ b/java/test/auto_check_sbp_system_MsgGroupMetaTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgGroupMeta.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgGroupMeta.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgGroupMeta; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgGroupMetaTest { @@ -27,28 +32,17 @@ public class auto_check_sbp_system_MsgGroupMetaTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgGroupMetaTest.test1"); - byte[] payload = - new byte[] { - (byte) 1, - (byte) 2, - (byte) 3, - (byte) 10, - (byte) 255, - (byte) 10, - (byte) 2, - (byte) 2, - (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0xEEEE, 0xFF0A, payload); - MsgGroupMeta msg = new MsgGroupMeta(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgGroupMetaTest.test1"); + byte[] payload = new byte[] {(byte)1,(byte)2,(byte)3,(byte)10,(byte)255,(byte)10,(byte)2,(byte)2,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0xEEEE, 0xFF0A, payload ); + MsgGroupMeta msg = new MsgGroupMeta( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -56,8 +50,7 @@ public void test1() throws Throwable { } value = msg.group_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.group_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -65,9 +58,7 @@ public void test1() throws Throwable { } value = msg.group_msgs[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[0] + "' != '" + 65290 + "'", - value.equals(BigInteger.valueOf(65290L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[0] + "' != '" + 65290 + "'", value.equals(BigInteger.valueOf( 65290L ) ) ); } else { value = value.longValue(); expected = 65290L; @@ -75,9 +66,7 @@ public void test1() throws Throwable { } value = msg.group_msgs[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[1] + "' != '" + 522 + "'", - value.equals(BigInteger.valueOf(522L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[1] + "' != '" + 522 + "'", value.equals(BigInteger.valueOf( 522L ) ) ); } else { value = value.longValue(); expected = 522L; @@ -85,9 +74,7 @@ public void test1() throws Throwable { } value = msg.group_msgs[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[2] + "' != '" + 65282 + "'", - value.equals(BigInteger.valueOf(65282L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[2] + "' != '" + 65282 + "'", value.equals(BigInteger.valueOf( 65282L ) ) ); } else { value = value.longValue(); expected = 65282L; @@ -95,9 +82,7 @@ public void test1() throws Throwable { } value = msg.n_group_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_group_msgs + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.n_group_msgs + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -109,24 +94,17 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgGroupMetaTest.test2"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 1, (byte) 14, (byte) 2, (byte) 1, (byte) 3, (byte) 1, - (byte) 10, (byte) 2, (byte) 17, (byte) 2, (byte) 9, (byte) 2, (byte) 20, - (byte) 2, (byte) 14, (byte) 2, (byte) 18, (byte) 2, (byte) 13, (byte) 2, - (byte) 21, (byte) 2, (byte) 33, (byte) 2, (byte) 3, (byte) 255, (byte) 6, - (byte) 255, (byte) 14, (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0x315, 0xFF0A, payload); - MsgGroupMeta msg = new MsgGroupMeta(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgGroupMetaTest.test2"); + byte[] payload = new byte[] {(byte)1,(byte)1,(byte)14,(byte)2,(byte)1,(byte)3,(byte)1,(byte)10,(byte)2,(byte)17,(byte)2,(byte)9,(byte)2,(byte)20,(byte)2,(byte)14,(byte)2,(byte)18,(byte)2,(byte)13,(byte)2,(byte)21,(byte)2,(byte)33,(byte)2,(byte)3,(byte)255,(byte)6,(byte)255,(byte)14,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0x315, 0xFF0A, payload ); + MsgGroupMeta msg = new MsgGroupMeta( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -134,8 +112,7 @@ public void test2() throws Throwable { } value = msg.group_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.group_id + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -143,9 +120,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[0] + "' != '" + 258 + "'", - value.equals(BigInteger.valueOf(258L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[0] + "' != '" + 258 + "'", value.equals(BigInteger.valueOf( 258L ) ) ); } else { value = value.longValue(); expected = 258L; @@ -153,9 +128,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[1] + "' != '" + 259 + "'", - value.equals(BigInteger.valueOf(259L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[1] + "' != '" + 259 + "'", value.equals(BigInteger.valueOf( 259L ) ) ); } else { value = value.longValue(); expected = 259L; @@ -163,9 +136,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[2] + "' != '" + 522 + "'", - value.equals(BigInteger.valueOf(522L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[2] + "' != '" + 522 + "'", value.equals(BigInteger.valueOf( 522L ) ) ); } else { value = value.longValue(); expected = 522L; @@ -173,9 +144,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[3] + "' != '" + 529 + "'", - value.equals(BigInteger.valueOf(529L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[3] + "' != '" + 529 + "'", value.equals(BigInteger.valueOf( 529L ) ) ); } else { value = value.longValue(); expected = 529L; @@ -183,9 +152,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[4] + "' != '" + 521 + "'", - value.equals(BigInteger.valueOf(521L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[4] + "' != '" + 521 + "'", value.equals(BigInteger.valueOf( 521L ) ) ); } else { value = value.longValue(); expected = 521L; @@ -193,9 +160,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[5] + "' != '" + 532 + "'", - value.equals(BigInteger.valueOf(532L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[5] + "' != '" + 532 + "'", value.equals(BigInteger.valueOf( 532L ) ) ); } else { value = value.longValue(); expected = 532L; @@ -203,9 +168,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[6] + "' != '" + 526 + "'", - value.equals(BigInteger.valueOf(526L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[6] + "' != '" + 526 + "'", value.equals(BigInteger.valueOf( 526L ) ) ); } else { value = value.longValue(); expected = 526L; @@ -213,9 +176,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[7] + "' != '" + 530 + "'", - value.equals(BigInteger.valueOf(530L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[7] + "' != '" + 530 + "'", value.equals(BigInteger.valueOf( 530L ) ) ); } else { value = value.longValue(); expected = 530L; @@ -223,9 +184,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[8] + "' != '" + 525 + "'", - value.equals(BigInteger.valueOf(525L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[8] + "' != '" + 525 + "'", value.equals(BigInteger.valueOf( 525L ) ) ); } else { value = value.longValue(); expected = 525L; @@ -233,9 +192,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[9] + "' != '" + 533 + "'", - value.equals(BigInteger.valueOf(533L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[9] + "' != '" + 533 + "'", value.equals(BigInteger.valueOf( 533L ) ) ); } else { value = value.longValue(); expected = 533L; @@ -243,9 +200,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[10] + "' != '" + 545 + "'", - value.equals(BigInteger.valueOf(545L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[10] + "' != '" + 545 + "'", value.equals(BigInteger.valueOf( 545L ) ) ); } else { value = value.longValue(); expected = 545L; @@ -253,9 +208,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[11] + "' != '" + 65283 + "'", - value.equals(BigInteger.valueOf(65283L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[11] + "' != '" + 65283 + "'", value.equals(BigInteger.valueOf( 65283L ) ) ); } else { value = value.longValue(); expected = 65283L; @@ -263,9 +216,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[12] + "' != '" + 65286 + "'", - value.equals(BigInteger.valueOf(65286L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[12] + "' != '" + 65286 + "'", value.equals(BigInteger.valueOf( 65286L ) ) ); } else { value = value.longValue(); expected = 65286L; @@ -273,9 +224,7 @@ public void test2() throws Throwable { } value = msg.group_msgs[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.group_msgs[13] + "' != '" + 65294 + "'", - value.equals(BigInteger.valueOf(65294L))); + org.junit.Assert.assertTrue("'" + msg.group_msgs[13] + "' != '" + 65294 + "'", value.equals(BigInteger.valueOf( 65294L ) ) ); } else { value = value.longValue(); expected = 65294L; @@ -283,9 +232,7 @@ public void test2() throws Throwable { } value = msg.n_group_msgs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_group_msgs + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.n_group_msgs + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; diff --git a/java/test/auto_check_sbp_system_MsgHeartbeatTest.java b/java/test/auto_check_sbp_system_MsgHeartbeatTest.java index bf61c0bec..ac79497aa 100644 --- a/java/test/auto_check_sbp_system_MsgHeartbeatTest.java +++ b/java/test/auto_check_sbp_system_MsgHeartbeatTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgHeartbeat.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgHeartbeat.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgHeartbeat; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgHeartbeatTest { @@ -27,21 +32,17 @@ public class auto_check_sbp_system_MsgHeartbeatTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgHeartbeatTest.test1"); - byte[] payload = - new byte[] { - (byte) 0, (byte) 50, (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0xffff, payload); - MsgHeartbeat msg = new MsgHeartbeat(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgHeartbeatTest.test1"); + byte[] payload = new byte[] {(byte)0,(byte)50,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0xffff, payload ); + MsgHeartbeat msg = new MsgHeartbeat( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 12800 + "'", - value.equals(BigInteger.valueOf(12800L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 12800 + "'", value.equals(BigInteger.valueOf( 12800L ) ) ); } else { value = value.longValue(); expected = 12800L; @@ -53,20 +54,17 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgHeartbeatTest.test2"); - byte[] payload = - new byte[] { - (byte) 0, (byte) 0, (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0xffff, payload); - MsgHeartbeat msg = new MsgHeartbeat(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgHeartbeatTest.test2"); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0xffff, payload ); + MsgHeartbeat msg = new MsgHeartbeat( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; diff --git a/java/test/auto_check_sbp_system_MsgInsStatusTest.java b/java/test/auto_check_sbp_system_MsgInsStatusTest.java index 71942471f..be053f267 100644 --- a/java/test/auto_check_sbp_system_MsgInsStatusTest.java +++ b/java/test/auto_check_sbp_system_MsgInsStatusTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgInsStatus.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgInsStatus.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgInsStatus; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgInsStatusTest { @@ -27,21 +32,17 @@ public class auto_check_sbp_system_MsgInsStatusTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgInsStatusTest.test1"); - byte[] payload = - new byte[] { - (byte) 9, (byte) 0, (byte) 0, (byte) 32, - }; - SBPMessage sbp = new SBPMessage(0x315, 0xff03, payload); - MsgInsStatus msg = new MsgInsStatus(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgInsStatusTest.test1"); + byte[] payload = new byte[] {(byte)9,(byte)0,(byte)0,(byte)32, }; + SBPMessage sbp = new SBPMessage( 0x315, 0xff03, payload ); + MsgInsStatus msg = new MsgInsStatus( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 536870921 + "'", - value.equals(BigInteger.valueOf(536870921L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 536870921 + "'", value.equals(BigInteger.valueOf( 536870921L ) ) ); } else { value = value.longValue(); expected = 536870921L; diff --git a/java/test/auto_check_sbp_system_MsgInsUpdatesTest.java b/java/test/auto_check_sbp_system_MsgInsUpdatesTest.java index 096b284bf..bc9c03b44 100644 --- a/java/test/auto_check_sbp_system_MsgInsUpdatesTest.java +++ b/java/test/auto_check_sbp_system_MsgInsUpdatesTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgInsUpdates.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgInsUpdates.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgInsUpdates; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgInsUpdatesTest { @@ -27,29 +32,17 @@ public class auto_check_sbp_system_MsgInsUpdatesTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgInsUpdatesTest.test1"); - byte[] payload = - new byte[] { - (byte) 84, - (byte) 229, - (byte) 17, - (byte) 30, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x315, 0xff06, payload); - MsgInsUpdates msg = new MsgInsUpdates(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgInsUpdatesTest.test1"); + byte[] payload = new byte[] {(byte)84,(byte)229,(byte)17,(byte)30,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x315, 0xff06, payload ); + MsgInsUpdates msg = new MsgInsUpdates( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.gnsspos; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gnsspos + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.gnsspos + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -57,8 +50,7 @@ public void test1() throws Throwable { } value = msg.gnssvel; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.gnssvel + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.gnssvel + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -66,8 +58,7 @@ public void test1() throws Throwable { } value = msg.nhc; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.nhc + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.nhc + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -75,8 +66,7 @@ public void test1() throws Throwable { } value = msg.speed; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.speed + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.speed + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -84,9 +74,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 504489300 + "'", - value.equals(BigInteger.valueOf(504489300L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 504489300 + "'", value.equals(BigInteger.valueOf( 504489300L ) ) ); } else { value = value.longValue(); expected = 504489300L; @@ -94,9 +82,7 @@ public void test1() throws Throwable { } value = msg.wheelticks; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wheelticks + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.wheelticks + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -104,8 +90,7 @@ public void test1() throws Throwable { } value = msg.zerovel; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.zerovel + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.zerovel + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; diff --git a/java/test/auto_check_sbp_system_MsgPpsTimeTest.java b/java/test/auto_check_sbp_system_MsgPpsTimeTest.java index 7870c0d18..bc2d57007 100644 --- a/java/test/auto_check_sbp_system_MsgPpsTimeTest.java +++ b/java/test/auto_check_sbp_system_MsgPpsTimeTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgPpsTime.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgPpsTime.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgPpsTime; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgPpsTimeTest { @@ -27,28 +32,17 @@ public class auto_check_sbp_system_MsgPpsTimeTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgPpsTimeTest.test1"); - byte[] payload = - new byte[] { - (byte) 140, - (byte) 146, - (byte) 133, - (byte) 197, - (byte) 160, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 255, - }; - SBPMessage sbp = new SBPMessage(0xd1de, 0xff08, payload); - MsgPpsTime msg = new MsgPpsTime(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgPpsTimeTest.test1"); + byte[] payload = new byte[] {(byte)140,(byte)146,(byte)133,(byte)197,(byte)160,(byte)0,(byte)0,(byte)0,(byte)255, }; + SBPMessage sbp = new SBPMessage( 0xd1de, 0xff08, payload ); + MsgPpsTime msg = new MsgPpsTime( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 255 + "'", value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -56,9 +50,7 @@ public void test1() throws Throwable { } value = msg.time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time + "' != '" + 690508632716L + "'", - value.equals(new BigInteger("690508632716"))); + org.junit.Assert.assertTrue("'" + msg.time + "' != '" + 690508632716L + "'", value.equals( new BigInteger( "690508632716" ) ) ); } else { value = value.longValue(); expected = 690508632716L; diff --git a/java/test/auto_check_sbp_system_MsgSensorAidEventTest.java b/java/test/auto_check_sbp_system_MsgSensorAidEventTest.java index 70d62d13b..f693adcca 100644 --- a/java/test/auto_check_sbp_system_MsgSensorAidEventTest.java +++ b/java/test/auto_check_sbp_system_MsgSensorAidEventTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgSensorAidEvent.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgSensorAidEvent.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgSensorAidEvent; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgSensorAidEventTest { @@ -27,34 +32,17 @@ public class auto_check_sbp_system_MsgSensorAidEventTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgSensorAidEventTest.test1"); - byte[] payload = - new byte[] { - (byte) 48, - (byte) 246, - (byte) 122, - (byte) 19, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x88D3, 0xFF09, payload); - MsgSensorAidEvent msg = new MsgSensorAidEvent(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgSensorAidEventTest.test1"); + byte[] payload = new byte[] {(byte)48,(byte)246,(byte)122,(byte)19,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x88D3, 0xFF09, payload ); + MsgSensorAidEvent msg = new MsgSensorAidEvent( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -62,9 +50,7 @@ public void test1() throws Throwable { } value = msg.n_accepted_meas; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_accepted_meas + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.n_accepted_meas + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -72,9 +58,7 @@ public void test1() throws Throwable { } value = msg.n_attempted_meas; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_attempted_meas + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.n_attempted_meas + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -82,9 +66,7 @@ public void test1() throws Throwable { } value = msg.n_available_meas; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_available_meas + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.n_available_meas + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -92,8 +74,7 @@ public void test1() throws Throwable { } value = msg.sensor_id; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sensor_id + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sensor_id + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -101,9 +82,7 @@ public void test1() throws Throwable { } value = msg.sensor_state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sensor_state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sensor_state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -111,9 +90,7 @@ public void test1() throws Throwable { } value = msg.sensor_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sensor_type + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sensor_type + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -121,9 +98,7 @@ public void test1() throws Throwable { } value = msg.time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time + "' != '" + 326825520 + "'", - value.equals(BigInteger.valueOf(326825520L))); + org.junit.Assert.assertTrue("'" + msg.time + "' != '" + 326825520 + "'", value.equals(BigInteger.valueOf( 326825520L ) ) ); } else { value = value.longValue(); expected = 326825520L; diff --git a/java/test/auto_check_sbp_system_MsgStartupTest.java b/java/test/auto_check_sbp_system_MsgStartupTest.java index b0d316f92..e21a492c2 100644 --- a/java/test/auto_check_sbp_system_MsgStartupTest.java +++ b/java/test/auto_check_sbp_system_MsgStartupTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgStartup.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgStartup.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgStartup; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgStartupTest { @@ -27,20 +32,17 @@ public class auto_check_sbp_system_MsgStartupTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgStartupTest.test1"); - byte[] payload = - new byte[] { - (byte) 0, (byte) 0, (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x42, 0xff00, payload); - MsgStartup msg = new MsgStartup(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgStartupTest.test1"); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x42, 0xff00, payload ); + MsgStartup msg = new MsgStartup( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.cause; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cause + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.cause + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -48,8 +50,7 @@ public void test1() throws Throwable { } value = msg.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -57,9 +58,7 @@ public void test1() throws Throwable { } value = msg.startup_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.startup_type + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.startup_type + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -71,20 +70,17 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgStartupTest.test2"); - byte[] payload = - new byte[] { - (byte) 0, (byte) 0, (byte) 0, (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0xff00, payload); - MsgStartup msg = new MsgStartup(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgStartupTest.test2"); + byte[] payload = new byte[] {(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0xff00, payload ); + MsgStartup msg = new MsgStartup( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.cause; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cause + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.cause + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -92,8 +88,7 @@ public void test2() throws Throwable { } value = msg.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -101,9 +96,7 @@ public void test2() throws Throwable { } value = msg.startup_type; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.startup_type + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.startup_type + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; diff --git a/java/test/auto_check_sbp_system_MsgStatusJournalTest.java b/java/test/auto_check_sbp_system_MsgStatusJournalTest.java index 090c13daf..9cf2c94f5 100644 --- a/java/test/auto_check_sbp_system_MsgStatusJournalTest.java +++ b/java/test/auto_check_sbp_system_MsgStatusJournalTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgStatusJournal.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgStatusJournal.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgStatusJournal; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgStatusJournalTest { @@ -27,25 +32,17 @@ public class auto_check_sbp_system_MsgStatusJournalTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgStatusJournalTest.test1"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 0, (byte) 1, (byte) 4, (byte) 100, (byte) 0, (byte) 0, - (byte) 0, (byte) 16, (byte) 146, (byte) 16, (byte) 0, (byte) 0, (byte) 6, - (byte) 0, (byte) 1, (byte) 13, (byte) 186, (byte) 19, (byte) 0, (byte) 0, - (byte) 6, (byte) 0, (byte) 1, (byte) 14, (byte) 184, (byte) 34, (byte) 0, - (byte) 0, (byte) 6, (byte) 0, (byte) 1, (byte) 15, - }; - SBPMessage sbp = new SBPMessage(0x88D3, 0xFFFD, payload); - MsgStatusJournal msg = new MsgStatusJournal(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgStatusJournalTest.test1"); + byte[] payload = new byte[] {(byte)1,(byte)0,(byte)1,(byte)4,(byte)100,(byte)0,(byte)0,(byte)0,(byte)16,(byte)146,(byte)16,(byte)0,(byte)0,(byte)6,(byte)0,(byte)1,(byte)13,(byte)186,(byte)19,(byte)0,(byte)0,(byte)6,(byte)0,(byte)1,(byte)14,(byte)184,(byte)34,(byte)0,(byte)0,(byte)6,(byte)0,(byte)1,(byte)15, }; + SBPMessage sbp = new SBPMessage( 0x88D3, 0xFFFD, payload ); + MsgStatusJournal msg = new MsgStatusJournal( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.journal[0].report.component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[0].report.component + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.journal[0].report.component + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -53,9 +50,7 @@ public void test1() throws Throwable { } value = msg.journal[0].report.generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[0].report.generic + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.journal[0].report.generic + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -63,9 +58,7 @@ public void test1() throws Throwable { } value = msg.journal[0].report.specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[0].report.specific + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.journal[0].report.specific + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -73,9 +66,7 @@ public void test1() throws Throwable { } value = msg.journal[0].uptime; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[0].uptime + "' != '" + 4242 + "'", - value.equals(BigInteger.valueOf(4242L))); + org.junit.Assert.assertTrue("'" + msg.journal[0].uptime + "' != '" + 4242 + "'", value.equals(BigInteger.valueOf( 4242L ) ) ); } else { value = value.longValue(); expected = 4242L; @@ -83,9 +74,7 @@ public void test1() throws Throwable { } value = msg.journal[1].report.component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[1].report.component + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.journal[1].report.component + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -93,9 +82,7 @@ public void test1() throws Throwable { } value = msg.journal[1].report.generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[1].report.generic + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.journal[1].report.generic + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -103,9 +90,7 @@ public void test1() throws Throwable { } value = msg.journal[1].report.specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[1].report.specific + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.journal[1].report.specific + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -113,9 +98,7 @@ public void test1() throws Throwable { } value = msg.journal[1].uptime; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[1].uptime + "' != '" + 5050 + "'", - value.equals(BigInteger.valueOf(5050L))); + org.junit.Assert.assertTrue("'" + msg.journal[1].uptime + "' != '" + 5050 + "'", value.equals(BigInteger.valueOf( 5050L ) ) ); } else { value = value.longValue(); expected = 5050L; @@ -123,9 +106,7 @@ public void test1() throws Throwable { } value = msg.journal[2].report.component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[2].report.component + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.journal[2].report.component + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -133,9 +114,7 @@ public void test1() throws Throwable { } value = msg.journal[2].report.generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[2].report.generic + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.journal[2].report.generic + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -143,9 +122,7 @@ public void test1() throws Throwable { } value = msg.journal[2].report.specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[2].report.specific + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.journal[2].report.specific + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -153,9 +130,7 @@ public void test1() throws Throwable { } value = msg.journal[2].uptime; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[2].uptime + "' != '" + 8888 + "'", - value.equals(BigInteger.valueOf(8888L))); + org.junit.Assert.assertTrue("'" + msg.journal[2].uptime + "' != '" + 8888 + "'", value.equals(BigInteger.valueOf( 8888L ) ) ); } else { value = value.longValue(); expected = 8888L; @@ -163,9 +138,7 @@ public void test1() throws Throwable { } value = msg.reporting_system; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reporting_system + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.reporting_system + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -173,9 +146,7 @@ public void test1() throws Throwable { } value = msg.sbp_version; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sbp_version + "' != '" + 1025 + "'", - value.equals(BigInteger.valueOf(1025L))); + org.junit.Assert.assertTrue("'" + msg.sbp_version + "' != '" + 1025 + "'", value.equals(BigInteger.valueOf( 1025L ) ) ); } else { value = value.longValue(); expected = 1025L; @@ -183,9 +154,7 @@ public void test1() throws Throwable { } value = msg.sequence_descriptor; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sequence_descriptor + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.sequence_descriptor + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -193,9 +162,7 @@ public void test1() throws Throwable { } value = msg.total_status_reports; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.total_status_reports + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.total_status_reports + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -207,23 +174,17 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgStatusJournalTest.test2"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 0, (byte) 1, (byte) 4, (byte) 100, (byte) 0, (byte) 0, - (byte) 0, (byte) 16, (byte) 146, (byte) 16, (byte) 0, (byte) 0, (byte) 6, - (byte) 0, (byte) 1, (byte) 13, - }; - SBPMessage sbp = new SBPMessage(0x88D3, 0xFFFD, payload); - MsgStatusJournal msg = new MsgStatusJournal(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgStatusJournalTest.test2"); + byte[] payload = new byte[] {(byte)1,(byte)0,(byte)1,(byte)4,(byte)100,(byte)0,(byte)0,(byte)0,(byte)16,(byte)146,(byte)16,(byte)0,(byte)0,(byte)6,(byte)0,(byte)1,(byte)13, }; + SBPMessage sbp = new SBPMessage( 0x88D3, 0xFFFD, payload ); + MsgStatusJournal msg = new MsgStatusJournal( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.journal[0].report.component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[0].report.component + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.journal[0].report.component + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -231,9 +192,7 @@ public void test2() throws Throwable { } value = msg.journal[0].report.generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[0].report.generic + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.journal[0].report.generic + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -241,9 +200,7 @@ public void test2() throws Throwable { } value = msg.journal[0].report.specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[0].report.specific + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.journal[0].report.specific + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -251,9 +208,7 @@ public void test2() throws Throwable { } value = msg.journal[0].uptime; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.journal[0].uptime + "' != '" + 4242 + "'", - value.equals(BigInteger.valueOf(4242L))); + org.junit.Assert.assertTrue("'" + msg.journal[0].uptime + "' != '" + 4242 + "'", value.equals(BigInteger.valueOf( 4242L ) ) ); } else { value = value.longValue(); expected = 4242L; @@ -261,9 +216,7 @@ public void test2() throws Throwable { } value = msg.reporting_system; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reporting_system + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.reporting_system + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -271,9 +224,7 @@ public void test2() throws Throwable { } value = msg.sbp_version; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sbp_version + "' != '" + 1025 + "'", - value.equals(BigInteger.valueOf(1025L))); + org.junit.Assert.assertTrue("'" + msg.sbp_version + "' != '" + 1025 + "'", value.equals(BigInteger.valueOf( 1025L ) ) ); } else { value = value.longValue(); expected = 1025L; @@ -281,9 +232,7 @@ public void test2() throws Throwable { } value = msg.sequence_descriptor; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sequence_descriptor + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.sequence_descriptor + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -291,9 +240,7 @@ public void test2() throws Throwable { } value = msg.total_status_reports; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.total_status_reports + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.total_status_reports + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; diff --git a/java/test/auto_check_sbp_system_MsgStatusReportTest.java b/java/test/auto_check_sbp_system_MsgStatusReportTest.java index 12c7cac85..76e2c03d6 100644 --- a/java/test/auto_check_sbp_system_MsgStatusReportTest.java +++ b/java/test/auto_check_sbp_system_MsgStatusReportTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgStatusReport.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_MsgStatusReport.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.system.MsgStatusReport; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_system_MsgStatusReportTest { @@ -27,272 +32,17 @@ public class auto_check_sbp_system_MsgStatusReportTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_system_MsgStatusReportTest.test1"); - byte[] payload = - new byte[] { - (byte) 82, - (byte) 253, - (byte) 177, - (byte) 95, - (byte) 3, - (byte) 60, - (byte) 143, - (byte) 90, - (byte) 233, - (byte) 21, - (byte) 208, - (byte) 98, - (byte) 247, - (byte) 203, - (byte) 221, - (byte) 198, - (byte) 156, - (byte) 207, - (byte) 217, - (byte) 238, - (byte) 162, - (byte) 136, - (byte) 154, - (byte) 11, - (byte) 114, - (byte) 236, - (byte) 134, - (byte) 235, - (byte) 12, - (byte) 133, - (byte) 9, - (byte) 30, - (byte) 175, - (byte) 145, - (byte) 26, - (byte) 114, - (byte) 215, - (byte) 20, - (byte) 146, - (byte) 249, - (byte) 54, - (byte) 54, - (byte) 133, - (byte) 193, - (byte) 106, - (byte) 186, - (byte) 210, - (byte) 183, - (byte) 0, - (byte) 129, - (byte) 5, - (byte) 248, - (byte) 225, - (byte) 149, - (byte) 135, - (byte) 127, - (byte) 2, - (byte) 26, - (byte) 88, - (byte) 92, - (byte) 10, - (byte) 103, - (byte) 73, - (byte) 3, - (byte) 103, - (byte) 68, - (byte) 76, - (byte) 184, - (byte) 33, - (byte) 206, - (byte) 194, - (byte) 163, - (byte) 123, - (byte) 30, - (byte) 151, - (byte) 176, - (byte) 149, - (byte) 172, - (byte) 184, - (byte) 231, - (byte) 118, - (byte) 230, - (byte) 200, - (byte) 168, - (byte) 100, - (byte) 109, - (byte) 10, - (byte) 233, - (byte) 4, - (byte) 60, - (byte) 247, - (byte) 82, - (byte) 215, - (byte) 166, - (byte) 28, - (byte) 138, - (byte) 110, - (byte) 45, - (byte) 98, - (byte) 218, - (byte) 244, - (byte) 179, - (byte) 126, - (byte) 107, - (byte) 92, - (byte) 124, - (byte) 94, - (byte) 157, - (byte) 42, - (byte) 187, - (byte) 124, - (byte) 6, - (byte) 97, - (byte) 247, - (byte) 160, - (byte) 188, - (byte) 110, - (byte) 120, - (byte) 254, - (byte) 214, - (byte) 110, - (byte) 51, - (byte) 240, - (byte) 164, - (byte) 147, - (byte) 18, - (byte) 74, - (byte) 178, - (byte) 67, - (byte) 4, - (byte) 27, - (byte) 73, - (byte) 190, - (byte) 64, - (byte) 179, - (byte) 146, - (byte) 125, - (byte) 153, - (byte) 192, - (byte) 46, - (byte) 202, - (byte) 66, - (byte) 248, - (byte) 46, - (byte) 40, - (byte) 161, - (byte) 173, - (byte) 242, - (byte) 214, - (byte) 3, - (byte) 11, - (byte) 1, - (byte) 118, - (byte) 70, - (byte) 162, - (byte) 61, - (byte) 178, - (byte) 27, - (byte) 156, - (byte) 40, - (byte) 191, - (byte) 113, - (byte) 230, - (byte) 200, - (byte) 72, - (byte) 8, - (byte) 215, - (byte) 245, - (byte) 78, - (byte) 59, - (byte) 222, - (byte) 250, - (byte) 115, - (byte) 32, - (byte) 33, - (byte) 30, - (byte) 211, - (byte) 170, - (byte) 145, - (byte) 92, - (byte) 157, - (byte) 75, - (byte) 24, - (byte) 169, - (byte) 6, - (byte) 55, - (byte) 62, - (byte) 8, - (byte) 107, - (byte) 82, - (byte) 140, - (byte) 49, - (byte) 179, - (byte) 122, - (byte) 90, - (byte) 71, - (byte) 28, - (byte) 88, - (byte) 103, - (byte) 51, - (byte) 177, - (byte) 72, - (byte) 93, - (byte) 39, - (byte) 148, - (byte) 11, - (byte) 202, - (byte) 42, - (byte) 34, - (byte) 92, - (byte) 204, - (byte) 102, - (byte) 29, - (byte) 98, - (byte) 249, - (byte) 91, - (byte) 134, - (byte) 95, - (byte) 23, - (byte) 248, - (byte) 192, - (byte) 20, - (byte) 83, - (byte) 195, - (byte) 95, - (byte) 180, - (byte) 54, - (byte) 36, - (byte) 186, - (byte) 75, - (byte) 64, - (byte) 20, - (byte) 157, - (byte) 133, - (byte) 12, - (byte) 149, - (byte) 28, - (byte) 14, - (byte) 185, - (byte) 129, - (byte) 101, - (byte) 239, - (byte) 74, - (byte) 248, - (byte) 245, - (byte) 30, - (byte) 228, - (byte) 88, - (byte) 142, - (byte) 212, - (byte) 53, - (byte) 224, - }; - SBPMessage sbp = new SBPMessage(0x5406, 0xfffe, payload); - MsgStatusReport msg = new MsgStatusReport(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_system_MsgStatusReportTest.test1"); + byte[] payload = new byte[] {(byte)82,(byte)253,(byte)177,(byte)95,(byte)3,(byte)60,(byte)143,(byte)90,(byte)233,(byte)21,(byte)208,(byte)98,(byte)247,(byte)203,(byte)221,(byte)198,(byte)156,(byte)207,(byte)217,(byte)238,(byte)162,(byte)136,(byte)154,(byte)11,(byte)114,(byte)236,(byte)134,(byte)235,(byte)12,(byte)133,(byte)9,(byte)30,(byte)175,(byte)145,(byte)26,(byte)114,(byte)215,(byte)20,(byte)146,(byte)249,(byte)54,(byte)54,(byte)133,(byte)193,(byte)106,(byte)186,(byte)210,(byte)183,(byte)0,(byte)129,(byte)5,(byte)248,(byte)225,(byte)149,(byte)135,(byte)127,(byte)2,(byte)26,(byte)88,(byte)92,(byte)10,(byte)103,(byte)73,(byte)3,(byte)103,(byte)68,(byte)76,(byte)184,(byte)33,(byte)206,(byte)194,(byte)163,(byte)123,(byte)30,(byte)151,(byte)176,(byte)149,(byte)172,(byte)184,(byte)231,(byte)118,(byte)230,(byte)200,(byte)168,(byte)100,(byte)109,(byte)10,(byte)233,(byte)4,(byte)60,(byte)247,(byte)82,(byte)215,(byte)166,(byte)28,(byte)138,(byte)110,(byte)45,(byte)98,(byte)218,(byte)244,(byte)179,(byte)126,(byte)107,(byte)92,(byte)124,(byte)94,(byte)157,(byte)42,(byte)187,(byte)124,(byte)6,(byte)97,(byte)247,(byte)160,(byte)188,(byte)110,(byte)120,(byte)254,(byte)214,(byte)110,(byte)51,(byte)240,(byte)164,(byte)147,(byte)18,(byte)74,(byte)178,(byte)67,(byte)4,(byte)27,(byte)73,(byte)190,(byte)64,(byte)179,(byte)146,(byte)125,(byte)153,(byte)192,(byte)46,(byte)202,(byte)66,(byte)248,(byte)46,(byte)40,(byte)161,(byte)173,(byte)242,(byte)214,(byte)3,(byte)11,(byte)1,(byte)118,(byte)70,(byte)162,(byte)61,(byte)178,(byte)27,(byte)156,(byte)40,(byte)191,(byte)113,(byte)230,(byte)200,(byte)72,(byte)8,(byte)215,(byte)245,(byte)78,(byte)59,(byte)222,(byte)250,(byte)115,(byte)32,(byte)33,(byte)30,(byte)211,(byte)170,(byte)145,(byte)92,(byte)157,(byte)75,(byte)24,(byte)169,(byte)6,(byte)55,(byte)62,(byte)8,(byte)107,(byte)82,(byte)140,(byte)49,(byte)179,(byte)122,(byte)90,(byte)71,(byte)28,(byte)88,(byte)103,(byte)51,(byte)177,(byte)72,(byte)93,(byte)39,(byte)148,(byte)11,(byte)202,(byte)42,(byte)34,(byte)92,(byte)204,(byte)102,(byte)29,(byte)98,(byte)249,(byte)91,(byte)134,(byte)95,(byte)23,(byte)248,(byte)192,(byte)20,(byte)83,(byte)195,(byte)95,(byte)180,(byte)54,(byte)36,(byte)186,(byte)75,(byte)64,(byte)20,(byte)157,(byte)133,(byte)12,(byte)149,(byte)28,(byte)14,(byte)185,(byte)129,(byte)101,(byte)239,(byte)74,(byte)248,(byte)245,(byte)30,(byte)228,(byte)88,(byte)142,(byte)212,(byte)53,(byte)224, }; + SBPMessage sbp = new SBPMessage( 0x5406, 0xfffe, payload ); + MsgStatusReport msg = new MsgStatusReport( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.reporting_system; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.reporting_system + "' != '" + 64850 + "'", - value.equals(BigInteger.valueOf(64850L))); + org.junit.Assert.assertTrue("'" + msg.reporting_system + "' != '" + 64850 + "'", value.equals(BigInteger.valueOf( 64850L ) ) ); } else { value = value.longValue(); expected = 64850L; @@ -300,9 +50,7 @@ public void test1() throws Throwable { } value = msg.sbp_version; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sbp_version + "' != '" + 24497 + "'", - value.equals(BigInteger.valueOf(24497L))); + org.junit.Assert.assertTrue("'" + msg.sbp_version + "' != '" + 24497 + "'", value.equals(BigInteger.valueOf( 24497L ) ) ); } else { value = value.longValue(); expected = 24497L; @@ -310,9 +58,7 @@ public void test1() throws Throwable { } value = msg.sequence; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sequence + "' != '" + 1519336451 + "'", - value.equals(BigInteger.valueOf(1519336451L))); + org.junit.Assert.assertTrue("'" + msg.sequence + "' != '" + 1519336451 + "'", value.equals(BigInteger.valueOf( 1519336451L ) ) ); } else { value = value.longValue(); expected = 1519336451L; @@ -320,9 +66,7 @@ public void test1() throws Throwable { } value = msg.status[0].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[0].component + "' != '" + 52215 + "'", - value.equals(BigInteger.valueOf(52215L))); + org.junit.Assert.assertTrue("'" + msg.status[0].component + "' != '" + 52215 + "'", value.equals(BigInteger.valueOf( 52215L ) ) ); } else { value = value.longValue(); expected = 52215L; @@ -330,9 +74,7 @@ public void test1() throws Throwable { } value = msg.status[0].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[0].generic + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.status[0].generic + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -340,9 +82,7 @@ public void test1() throws Throwable { } value = msg.status[0].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[0].specific + "' != '" + 198 + "'", - value.equals(BigInteger.valueOf(198L))); + org.junit.Assert.assertTrue("'" + msg.status[0].specific + "' != '" + 198 + "'", value.equals(BigInteger.valueOf( 198L ) ) ); } else { value = value.longValue(); expected = 198L; @@ -350,9 +90,7 @@ public void test1() throws Throwable { } value = msg.status[1].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[1].component + "' != '" + 53148 + "'", - value.equals(BigInteger.valueOf(53148L))); + org.junit.Assert.assertTrue("'" + msg.status[1].component + "' != '" + 53148 + "'", value.equals(BigInteger.valueOf( 53148L ) ) ); } else { value = value.longValue(); expected = 53148L; @@ -360,9 +98,7 @@ public void test1() throws Throwable { } value = msg.status[1].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[1].generic + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.status[1].generic + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -370,9 +106,7 @@ public void test1() throws Throwable { } value = msg.status[1].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[1].specific + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.status[1].specific + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -380,9 +114,7 @@ public void test1() throws Throwable { } value = msg.status[2].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[2].component + "' != '" + 34978 + "'", - value.equals(BigInteger.valueOf(34978L))); + org.junit.Assert.assertTrue("'" + msg.status[2].component + "' != '" + 34978 + "'", value.equals(BigInteger.valueOf( 34978L ) ) ); } else { value = value.longValue(); expected = 34978L; @@ -390,9 +122,7 @@ public void test1() throws Throwable { } value = msg.status[2].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[2].generic + "' != '" + 154 + "'", - value.equals(BigInteger.valueOf(154L))); + org.junit.Assert.assertTrue("'" + msg.status[2].generic + "' != '" + 154 + "'", value.equals(BigInteger.valueOf( 154L ) ) ); } else { value = value.longValue(); expected = 154L; @@ -400,9 +130,7 @@ public void test1() throws Throwable { } value = msg.status[2].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[2].specific + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.status[2].specific + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -410,9 +138,7 @@ public void test1() throws Throwable { } value = msg.status[3].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[3].component + "' != '" + 60530 + "'", - value.equals(BigInteger.valueOf(60530L))); + org.junit.Assert.assertTrue("'" + msg.status[3].component + "' != '" + 60530 + "'", value.equals(BigInteger.valueOf( 60530L ) ) ); } else { value = value.longValue(); expected = 60530L; @@ -420,9 +146,7 @@ public void test1() throws Throwable { } value = msg.status[3].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[3].generic + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.status[3].generic + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -430,9 +154,7 @@ public void test1() throws Throwable { } value = msg.status[3].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[3].specific + "' != '" + 235 + "'", - value.equals(BigInteger.valueOf(235L))); + org.junit.Assert.assertTrue("'" + msg.status[3].specific + "' != '" + 235 + "'", value.equals(BigInteger.valueOf( 235L ) ) ); } else { value = value.longValue(); expected = 235L; @@ -440,9 +162,7 @@ public void test1() throws Throwable { } value = msg.status[4].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[4].component + "' != '" + 34060 + "'", - value.equals(BigInteger.valueOf(34060L))); + org.junit.Assert.assertTrue("'" + msg.status[4].component + "' != '" + 34060 + "'", value.equals(BigInteger.valueOf( 34060L ) ) ); } else { value = value.longValue(); expected = 34060L; @@ -450,9 +170,7 @@ public void test1() throws Throwable { } value = msg.status[4].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[4].generic + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.status[4].generic + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -460,9 +178,7 @@ public void test1() throws Throwable { } value = msg.status[4].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[4].specific + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.status[4].specific + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -470,9 +186,7 @@ public void test1() throws Throwable { } value = msg.status[5].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[5].component + "' != '" + 37295 + "'", - value.equals(BigInteger.valueOf(37295L))); + org.junit.Assert.assertTrue("'" + msg.status[5].component + "' != '" + 37295 + "'", value.equals(BigInteger.valueOf( 37295L ) ) ); } else { value = value.longValue(); expected = 37295L; @@ -480,9 +194,7 @@ public void test1() throws Throwable { } value = msg.status[5].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[5].generic + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.status[5].generic + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -490,9 +202,7 @@ public void test1() throws Throwable { } value = msg.status[5].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[5].specific + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.status[5].specific + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -500,9 +210,7 @@ public void test1() throws Throwable { } value = msg.status[6].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[6].component + "' != '" + 5335 + "'", - value.equals(BigInteger.valueOf(5335L))); + org.junit.Assert.assertTrue("'" + msg.status[6].component + "' != '" + 5335 + "'", value.equals(BigInteger.valueOf( 5335L ) ) ); } else { value = value.longValue(); expected = 5335L; @@ -510,9 +218,7 @@ public void test1() throws Throwable { } value = msg.status[6].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[6].generic + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.status[6].generic + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -520,9 +226,7 @@ public void test1() throws Throwable { } value = msg.status[6].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[6].specific + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.status[6].specific + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -530,9 +234,7 @@ public void test1() throws Throwable { } value = msg.status[7].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[7].component + "' != '" + 13878 + "'", - value.equals(BigInteger.valueOf(13878L))); + org.junit.Assert.assertTrue("'" + msg.status[7].component + "' != '" + 13878 + "'", value.equals(BigInteger.valueOf( 13878L ) ) ); } else { value = value.longValue(); expected = 13878L; @@ -540,9 +242,7 @@ public void test1() throws Throwable { } value = msg.status[7].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[7].generic + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.status[7].generic + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -550,9 +250,7 @@ public void test1() throws Throwable { } value = msg.status[7].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[7].specific + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.status[7].specific + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -560,9 +258,7 @@ public void test1() throws Throwable { } value = msg.status[8].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[8].component + "' != '" + 47722 + "'", - value.equals(BigInteger.valueOf(47722L))); + org.junit.Assert.assertTrue("'" + msg.status[8].component + "' != '" + 47722 + "'", value.equals(BigInteger.valueOf( 47722L ) ) ); } else { value = value.longValue(); expected = 47722L; @@ -570,9 +266,7 @@ public void test1() throws Throwable { } value = msg.status[8].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[8].generic + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.status[8].generic + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -580,9 +274,7 @@ public void test1() throws Throwable { } value = msg.status[8].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[8].specific + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.status[8].specific + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -590,9 +282,7 @@ public void test1() throws Throwable { } value = msg.status[9].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[9].component + "' != '" + 33024 + "'", - value.equals(BigInteger.valueOf(33024L))); + org.junit.Assert.assertTrue("'" + msg.status[9].component + "' != '" + 33024 + "'", value.equals(BigInteger.valueOf( 33024L ) ) ); } else { value = value.longValue(); expected = 33024L; @@ -600,9 +290,7 @@ public void test1() throws Throwable { } value = msg.status[9].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[9].generic + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.status[9].generic + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -610,9 +298,7 @@ public void test1() throws Throwable { } value = msg.status[9].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[9].specific + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.status[9].specific + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -620,9 +306,7 @@ public void test1() throws Throwable { } value = msg.status[10].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[10].component + "' != '" + 38369 + "'", - value.equals(BigInteger.valueOf(38369L))); + org.junit.Assert.assertTrue("'" + msg.status[10].component + "' != '" + 38369 + "'", value.equals(BigInteger.valueOf( 38369L ) ) ); } else { value = value.longValue(); expected = 38369L; @@ -630,9 +314,7 @@ public void test1() throws Throwable { } value = msg.status[10].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[10].generic + "' != '" + 135 + "'", - value.equals(BigInteger.valueOf(135L))); + org.junit.Assert.assertTrue("'" + msg.status[10].generic + "' != '" + 135 + "'", value.equals(BigInteger.valueOf( 135L ) ) ); } else { value = value.longValue(); expected = 135L; @@ -640,9 +322,7 @@ public void test1() throws Throwable { } value = msg.status[10].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[10].specific + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.status[10].specific + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -650,9 +330,7 @@ public void test1() throws Throwable { } value = msg.status[11].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[11].component + "' != '" + 6658 + "'", - value.equals(BigInteger.valueOf(6658L))); + org.junit.Assert.assertTrue("'" + msg.status[11].component + "' != '" + 6658 + "'", value.equals(BigInteger.valueOf( 6658L ) ) ); } else { value = value.longValue(); expected = 6658L; @@ -660,9 +338,7 @@ public void test1() throws Throwable { } value = msg.status[11].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[11].generic + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.status[11].generic + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -670,9 +346,7 @@ public void test1() throws Throwable { } value = msg.status[11].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[11].specific + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.status[11].specific + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -680,9 +354,7 @@ public void test1() throws Throwable { } value = msg.status[12].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[12].component + "' != '" + 26378 + "'", - value.equals(BigInteger.valueOf(26378L))); + org.junit.Assert.assertTrue("'" + msg.status[12].component + "' != '" + 26378 + "'", value.equals(BigInteger.valueOf( 26378L ) ) ); } else { value = value.longValue(); expected = 26378L; @@ -690,9 +362,7 @@ public void test1() throws Throwable { } value = msg.status[12].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[12].generic + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.status[12].generic + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -700,9 +370,7 @@ public void test1() throws Throwable { } value = msg.status[12].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[12].specific + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.status[12].specific + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -710,9 +378,7 @@ public void test1() throws Throwable { } value = msg.status[13].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[13].component + "' != '" + 17511 + "'", - value.equals(BigInteger.valueOf(17511L))); + org.junit.Assert.assertTrue("'" + msg.status[13].component + "' != '" + 17511 + "'", value.equals(BigInteger.valueOf( 17511L ) ) ); } else { value = value.longValue(); expected = 17511L; @@ -720,9 +386,7 @@ public void test1() throws Throwable { } value = msg.status[13].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[13].generic + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.status[13].generic + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -730,9 +394,7 @@ public void test1() throws Throwable { } value = msg.status[13].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[13].specific + "' != '" + 184 + "'", - value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.status[13].specific + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -740,9 +402,7 @@ public void test1() throws Throwable { } value = msg.status[14].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[14].component + "' != '" + 52769 + "'", - value.equals(BigInteger.valueOf(52769L))); + org.junit.Assert.assertTrue("'" + msg.status[14].component + "' != '" + 52769 + "'", value.equals(BigInteger.valueOf( 52769L ) ) ); } else { value = value.longValue(); expected = 52769L; @@ -750,9 +410,7 @@ public void test1() throws Throwable { } value = msg.status[14].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[14].generic + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.status[14].generic + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -760,9 +418,7 @@ public void test1() throws Throwable { } value = msg.status[14].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[14].specific + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.status[14].specific + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -770,9 +426,7 @@ public void test1() throws Throwable { } value = msg.status[15].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[15].component + "' != '" + 7803 + "'", - value.equals(BigInteger.valueOf(7803L))); + org.junit.Assert.assertTrue("'" + msg.status[15].component + "' != '" + 7803 + "'", value.equals(BigInteger.valueOf( 7803L ) ) ); } else { value = value.longValue(); expected = 7803L; @@ -780,9 +434,7 @@ public void test1() throws Throwable { } value = msg.status[15].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[15].generic + "' != '" + 151 + "'", - value.equals(BigInteger.valueOf(151L))); + org.junit.Assert.assertTrue("'" + msg.status[15].generic + "' != '" + 151 + "'", value.equals(BigInteger.valueOf( 151L ) ) ); } else { value = value.longValue(); expected = 151L; @@ -790,9 +442,7 @@ public void test1() throws Throwable { } value = msg.status[15].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[15].specific + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.status[15].specific + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -800,9 +450,7 @@ public void test1() throws Throwable { } value = msg.status[16].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[16].component + "' != '" + 44181 + "'", - value.equals(BigInteger.valueOf(44181L))); + org.junit.Assert.assertTrue("'" + msg.status[16].component + "' != '" + 44181 + "'", value.equals(BigInteger.valueOf( 44181L ) ) ); } else { value = value.longValue(); expected = 44181L; @@ -810,9 +458,7 @@ public void test1() throws Throwable { } value = msg.status[16].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[16].generic + "' != '" + 184 + "'", - value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.status[16].generic + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -820,9 +466,7 @@ public void test1() throws Throwable { } value = msg.status[16].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[16].specific + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.status[16].specific + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -830,9 +474,7 @@ public void test1() throws Throwable { } value = msg.status[17].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[17].component + "' != '" + 58998 + "'", - value.equals(BigInteger.valueOf(58998L))); + org.junit.Assert.assertTrue("'" + msg.status[17].component + "' != '" + 58998 + "'", value.equals(BigInteger.valueOf( 58998L ) ) ); } else { value = value.longValue(); expected = 58998L; @@ -840,9 +482,7 @@ public void test1() throws Throwable { } value = msg.status[17].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[17].generic + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.status[17].generic + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -850,9 +490,7 @@ public void test1() throws Throwable { } value = msg.status[17].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[17].specific + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.status[17].specific + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -860,9 +498,7 @@ public void test1() throws Throwable { } value = msg.status[18].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[18].component + "' != '" + 28004 + "'", - value.equals(BigInteger.valueOf(28004L))); + org.junit.Assert.assertTrue("'" + msg.status[18].component + "' != '" + 28004 + "'", value.equals(BigInteger.valueOf( 28004L ) ) ); } else { value = value.longValue(); expected = 28004L; @@ -870,9 +506,7 @@ public void test1() throws Throwable { } value = msg.status[18].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[18].generic + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.status[18].generic + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -880,9 +514,7 @@ public void test1() throws Throwable { } value = msg.status[18].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[18].specific + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.status[18].specific + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -890,9 +522,7 @@ public void test1() throws Throwable { } value = msg.status[19].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[19].component + "' != '" + 15364 + "'", - value.equals(BigInteger.valueOf(15364L))); + org.junit.Assert.assertTrue("'" + msg.status[19].component + "' != '" + 15364 + "'", value.equals(BigInteger.valueOf( 15364L ) ) ); } else { value = value.longValue(); expected = 15364L; @@ -900,9 +530,7 @@ public void test1() throws Throwable { } value = msg.status[19].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[19].generic + "' != '" + 247 + "'", - value.equals(BigInteger.valueOf(247L))); + org.junit.Assert.assertTrue("'" + msg.status[19].generic + "' != '" + 247 + "'", value.equals(BigInteger.valueOf( 247L ) ) ); } else { value = value.longValue(); expected = 247L; @@ -910,9 +538,7 @@ public void test1() throws Throwable { } value = msg.status[19].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[19].specific + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.status[19].specific + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -920,9 +546,7 @@ public void test1() throws Throwable { } value = msg.status[20].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[20].component + "' != '" + 42711 + "'", - value.equals(BigInteger.valueOf(42711L))); + org.junit.Assert.assertTrue("'" + msg.status[20].component + "' != '" + 42711 + "'", value.equals(BigInteger.valueOf( 42711L ) ) ); } else { value = value.longValue(); expected = 42711L; @@ -930,9 +554,7 @@ public void test1() throws Throwable { } value = msg.status[20].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[20].generic + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.status[20].generic + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -940,9 +562,7 @@ public void test1() throws Throwable { } value = msg.status[20].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[20].specific + "' != '" + 138 + "'", - value.equals(BigInteger.valueOf(138L))); + org.junit.Assert.assertTrue("'" + msg.status[20].specific + "' != '" + 138 + "'", value.equals(BigInteger.valueOf( 138L ) ) ); } else { value = value.longValue(); expected = 138L; @@ -950,9 +570,7 @@ public void test1() throws Throwable { } value = msg.status[21].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[21].component + "' != '" + 11630 + "'", - value.equals(BigInteger.valueOf(11630L))); + org.junit.Assert.assertTrue("'" + msg.status[21].component + "' != '" + 11630 + "'", value.equals(BigInteger.valueOf( 11630L ) ) ); } else { value = value.longValue(); expected = 11630L; @@ -960,9 +578,7 @@ public void test1() throws Throwable { } value = msg.status[21].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[21].generic + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.status[21].generic + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -970,9 +586,7 @@ public void test1() throws Throwable { } value = msg.status[21].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[21].specific + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.status[21].specific + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -980,9 +594,7 @@ public void test1() throws Throwable { } value = msg.status[22].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[22].component + "' != '" + 46068 + "'", - value.equals(BigInteger.valueOf(46068L))); + org.junit.Assert.assertTrue("'" + msg.status[22].component + "' != '" + 46068 + "'", value.equals(BigInteger.valueOf( 46068L ) ) ); } else { value = value.longValue(); expected = 46068L; @@ -990,9 +602,7 @@ public void test1() throws Throwable { } value = msg.status[22].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[22].generic + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.status[22].generic + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -1000,9 +610,7 @@ public void test1() throws Throwable { } value = msg.status[22].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[22].specific + "' != '" + 107 + "'", - value.equals(BigInteger.valueOf(107L))); + org.junit.Assert.assertTrue("'" + msg.status[22].specific + "' != '" + 107 + "'", value.equals(BigInteger.valueOf( 107L ) ) ); } else { value = value.longValue(); expected = 107L; @@ -1010,9 +618,7 @@ public void test1() throws Throwable { } value = msg.status[23].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[23].component + "' != '" + 31836 + "'", - value.equals(BigInteger.valueOf(31836L))); + org.junit.Assert.assertTrue("'" + msg.status[23].component + "' != '" + 31836 + "'", value.equals(BigInteger.valueOf( 31836L ) ) ); } else { value = value.longValue(); expected = 31836L; @@ -1020,9 +626,7 @@ public void test1() throws Throwable { } value = msg.status[23].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[23].generic + "' != '" + 94 + "'", - value.equals(BigInteger.valueOf(94L))); + org.junit.Assert.assertTrue("'" + msg.status[23].generic + "' != '" + 94 + "'", value.equals(BigInteger.valueOf( 94L ) ) ); } else { value = value.longValue(); expected = 94L; @@ -1030,9 +634,7 @@ public void test1() throws Throwable { } value = msg.status[23].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[23].specific + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.status[23].specific + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -1040,9 +642,7 @@ public void test1() throws Throwable { } value = msg.status[24].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[24].component + "' != '" + 47914 + "'", - value.equals(BigInteger.valueOf(47914L))); + org.junit.Assert.assertTrue("'" + msg.status[24].component + "' != '" + 47914 + "'", value.equals(BigInteger.valueOf( 47914L ) ) ); } else { value = value.longValue(); expected = 47914L; @@ -1050,9 +650,7 @@ public void test1() throws Throwable { } value = msg.status[24].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[24].generic + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.status[24].generic + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -1060,9 +658,7 @@ public void test1() throws Throwable { } value = msg.status[24].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[24].specific + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.status[24].specific + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1070,9 +666,7 @@ public void test1() throws Throwable { } value = msg.status[25].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[25].component + "' != '" + 63329 + "'", - value.equals(BigInteger.valueOf(63329L))); + org.junit.Assert.assertTrue("'" + msg.status[25].component + "' != '" + 63329 + "'", value.equals(BigInteger.valueOf( 63329L ) ) ); } else { value = value.longValue(); expected = 63329L; @@ -1080,9 +674,7 @@ public void test1() throws Throwable { } value = msg.status[25].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[25].generic + "' != '" + 160 + "'", - value.equals(BigInteger.valueOf(160L))); + org.junit.Assert.assertTrue("'" + msg.status[25].generic + "' != '" + 160 + "'", value.equals(BigInteger.valueOf( 160L ) ) ); } else { value = value.longValue(); expected = 160L; @@ -1090,9 +682,7 @@ public void test1() throws Throwable { } value = msg.status[25].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[25].specific + "' != '" + 188 + "'", - value.equals(BigInteger.valueOf(188L))); + org.junit.Assert.assertTrue("'" + msg.status[25].specific + "' != '" + 188 + "'", value.equals(BigInteger.valueOf( 188L ) ) ); } else { value = value.longValue(); expected = 188L; @@ -1100,9 +690,7 @@ public void test1() throws Throwable { } value = msg.status[26].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[26].component + "' != '" + 30830 + "'", - value.equals(BigInteger.valueOf(30830L))); + org.junit.Assert.assertTrue("'" + msg.status[26].component + "' != '" + 30830 + "'", value.equals(BigInteger.valueOf( 30830L ) ) ); } else { value = value.longValue(); expected = 30830L; @@ -1110,9 +698,7 @@ public void test1() throws Throwable { } value = msg.status[26].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[26].generic + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.status[26].generic + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -1120,9 +706,7 @@ public void test1() throws Throwable { } value = msg.status[26].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[26].specific + "' != '" + 214 + "'", - value.equals(BigInteger.valueOf(214L))); + org.junit.Assert.assertTrue("'" + msg.status[26].specific + "' != '" + 214 + "'", value.equals(BigInteger.valueOf( 214L ) ) ); } else { value = value.longValue(); expected = 214L; @@ -1130,9 +714,7 @@ public void test1() throws Throwable { } value = msg.status[27].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[27].component + "' != '" + 13166 + "'", - value.equals(BigInteger.valueOf(13166L))); + org.junit.Assert.assertTrue("'" + msg.status[27].component + "' != '" + 13166 + "'", value.equals(BigInteger.valueOf( 13166L ) ) ); } else { value = value.longValue(); expected = 13166L; @@ -1140,9 +722,7 @@ public void test1() throws Throwable { } value = msg.status[27].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[27].generic + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.status[27].generic + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -1150,9 +730,7 @@ public void test1() throws Throwable { } value = msg.status[27].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[27].specific + "' != '" + 164 + "'", - value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.status[27].specific + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -1160,9 +738,7 @@ public void test1() throws Throwable { } value = msg.status[28].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[28].component + "' != '" + 4755 + "'", - value.equals(BigInteger.valueOf(4755L))); + org.junit.Assert.assertTrue("'" + msg.status[28].component + "' != '" + 4755 + "'", value.equals(BigInteger.valueOf( 4755L ) ) ); } else { value = value.longValue(); expected = 4755L; @@ -1170,9 +746,7 @@ public void test1() throws Throwable { } value = msg.status[28].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[28].generic + "' != '" + 74 + "'", - value.equals(BigInteger.valueOf(74L))); + org.junit.Assert.assertTrue("'" + msg.status[28].generic + "' != '" + 74 + "'", value.equals(BigInteger.valueOf( 74L ) ) ); } else { value = value.longValue(); expected = 74L; @@ -1180,9 +754,7 @@ public void test1() throws Throwable { } value = msg.status[28].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[28].specific + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.status[28].specific + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -1190,9 +762,7 @@ public void test1() throws Throwable { } value = msg.status[29].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[29].component + "' != '" + 1091 + "'", - value.equals(BigInteger.valueOf(1091L))); + org.junit.Assert.assertTrue("'" + msg.status[29].component + "' != '" + 1091 + "'", value.equals(BigInteger.valueOf( 1091L ) ) ); } else { value = value.longValue(); expected = 1091L; @@ -1200,9 +770,7 @@ public void test1() throws Throwable { } value = msg.status[29].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[29].generic + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.status[29].generic + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -1210,9 +778,7 @@ public void test1() throws Throwable { } value = msg.status[29].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[29].specific + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.status[29].specific + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -1220,9 +786,7 @@ public void test1() throws Throwable { } value = msg.status[30].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[30].component + "' != '" + 16574 + "'", - value.equals(BigInteger.valueOf(16574L))); + org.junit.Assert.assertTrue("'" + msg.status[30].component + "' != '" + 16574 + "'", value.equals(BigInteger.valueOf( 16574L ) ) ); } else { value = value.longValue(); expected = 16574L; @@ -1230,9 +794,7 @@ public void test1() throws Throwable { } value = msg.status[30].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[30].generic + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.status[30].generic + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -1240,9 +802,7 @@ public void test1() throws Throwable { } value = msg.status[30].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[30].specific + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.status[30].specific + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -1250,9 +810,7 @@ public void test1() throws Throwable { } value = msg.status[31].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[31].component + "' != '" + 39293 + "'", - value.equals(BigInteger.valueOf(39293L))); + org.junit.Assert.assertTrue("'" + msg.status[31].component + "' != '" + 39293 + "'", value.equals(BigInteger.valueOf( 39293L ) ) ); } else { value = value.longValue(); expected = 39293L; @@ -1260,9 +818,7 @@ public void test1() throws Throwable { } value = msg.status[31].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[31].generic + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.status[31].generic + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -1270,9 +826,7 @@ public void test1() throws Throwable { } value = msg.status[31].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[31].specific + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.status[31].specific + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -1280,9 +834,7 @@ public void test1() throws Throwable { } value = msg.status[32].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[32].component + "' != '" + 17098 + "'", - value.equals(BigInteger.valueOf(17098L))); + org.junit.Assert.assertTrue("'" + msg.status[32].component + "' != '" + 17098 + "'", value.equals(BigInteger.valueOf( 17098L ) ) ); } else { value = value.longValue(); expected = 17098L; @@ -1290,9 +842,7 @@ public void test1() throws Throwable { } value = msg.status[32].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[32].generic + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.status[32].generic + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -1300,9 +850,7 @@ public void test1() throws Throwable { } value = msg.status[32].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[32].specific + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.status[32].specific + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -1310,9 +858,7 @@ public void test1() throws Throwable { } value = msg.status[33].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[33].component + "' != '" + 41256 + "'", - value.equals(BigInteger.valueOf(41256L))); + org.junit.Assert.assertTrue("'" + msg.status[33].component + "' != '" + 41256 + "'", value.equals(BigInteger.valueOf( 41256L ) ) ); } else { value = value.longValue(); expected = 41256L; @@ -1320,9 +866,7 @@ public void test1() throws Throwable { } value = msg.status[33].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[33].generic + "' != '" + 173 + "'", - value.equals(BigInteger.valueOf(173L))); + org.junit.Assert.assertTrue("'" + msg.status[33].generic + "' != '" + 173 + "'", value.equals(BigInteger.valueOf( 173L ) ) ); } else { value = value.longValue(); expected = 173L; @@ -1330,9 +874,7 @@ public void test1() throws Throwable { } value = msg.status[33].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[33].specific + "' != '" + 242 + "'", - value.equals(BigInteger.valueOf(242L))); + org.junit.Assert.assertTrue("'" + msg.status[33].specific + "' != '" + 242 + "'", value.equals(BigInteger.valueOf( 242L ) ) ); } else { value = value.longValue(); expected = 242L; @@ -1340,9 +882,7 @@ public void test1() throws Throwable { } value = msg.status[34].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[34].component + "' != '" + 982 + "'", - value.equals(BigInteger.valueOf(982L))); + org.junit.Assert.assertTrue("'" + msg.status[34].component + "' != '" + 982 + "'", value.equals(BigInteger.valueOf( 982L ) ) ); } else { value = value.longValue(); expected = 982L; @@ -1350,9 +890,7 @@ public void test1() throws Throwable { } value = msg.status[34].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[34].generic + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.status[34].generic + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -1360,9 +898,7 @@ public void test1() throws Throwable { } value = msg.status[34].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[34].specific + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.status[34].specific + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1370,9 +906,7 @@ public void test1() throws Throwable { } value = msg.status[35].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[35].component + "' != '" + 18038 + "'", - value.equals(BigInteger.valueOf(18038L))); + org.junit.Assert.assertTrue("'" + msg.status[35].component + "' != '" + 18038 + "'", value.equals(BigInteger.valueOf( 18038L ) ) ); } else { value = value.longValue(); expected = 18038L; @@ -1380,9 +914,7 @@ public void test1() throws Throwable { } value = msg.status[35].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[35].generic + "' != '" + 162 + "'", - value.equals(BigInteger.valueOf(162L))); + org.junit.Assert.assertTrue("'" + msg.status[35].generic + "' != '" + 162 + "'", value.equals(BigInteger.valueOf( 162L ) ) ); } else { value = value.longValue(); expected = 162L; @@ -1390,9 +922,7 @@ public void test1() throws Throwable { } value = msg.status[35].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[35].specific + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.status[35].specific + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -1400,9 +930,7 @@ public void test1() throws Throwable { } value = msg.status[36].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[36].component + "' != '" + 7090 + "'", - value.equals(BigInteger.valueOf(7090L))); + org.junit.Assert.assertTrue("'" + msg.status[36].component + "' != '" + 7090 + "'", value.equals(BigInteger.valueOf( 7090L ) ) ); } else { value = value.longValue(); expected = 7090L; @@ -1410,9 +938,7 @@ public void test1() throws Throwable { } value = msg.status[36].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[36].generic + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.status[36].generic + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -1420,9 +946,7 @@ public void test1() throws Throwable { } value = msg.status[36].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[36].specific + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.status[36].specific + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -1430,9 +954,7 @@ public void test1() throws Throwable { } value = msg.status[37].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[37].component + "' != '" + 29119 + "'", - value.equals(BigInteger.valueOf(29119L))); + org.junit.Assert.assertTrue("'" + msg.status[37].component + "' != '" + 29119 + "'", value.equals(BigInteger.valueOf( 29119L ) ) ); } else { value = value.longValue(); expected = 29119L; @@ -1440,9 +962,7 @@ public void test1() throws Throwable { } value = msg.status[37].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[37].generic + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.status[37].generic + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1450,9 +970,7 @@ public void test1() throws Throwable { } value = msg.status[37].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[37].specific + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.status[37].specific + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -1460,9 +978,7 @@ public void test1() throws Throwable { } value = msg.status[38].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[38].component + "' != '" + 2120 + "'", - value.equals(BigInteger.valueOf(2120L))); + org.junit.Assert.assertTrue("'" + msg.status[38].component + "' != '" + 2120 + "'", value.equals(BigInteger.valueOf( 2120L ) ) ); } else { value = value.longValue(); expected = 2120L; @@ -1470,9 +986,7 @@ public void test1() throws Throwable { } value = msg.status[38].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[38].generic + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.status[38].generic + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -1480,9 +994,7 @@ public void test1() throws Throwable { } value = msg.status[38].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[38].specific + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.status[38].specific + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -1490,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.status[39].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[39].component + "' != '" + 15182 + "'", - value.equals(BigInteger.valueOf(15182L))); + org.junit.Assert.assertTrue("'" + msg.status[39].component + "' != '" + 15182 + "'", value.equals(BigInteger.valueOf( 15182L ) ) ); } else { value = value.longValue(); expected = 15182L; @@ -1500,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.status[39].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[39].generic + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.status[39].generic + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -1510,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.status[39].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[39].specific + "' != '" + 250 + "'", - value.equals(BigInteger.valueOf(250L))); + org.junit.Assert.assertTrue("'" + msg.status[39].specific + "' != '" + 250 + "'", value.equals(BigInteger.valueOf( 250L ) ) ); } else { value = value.longValue(); expected = 250L; @@ -1520,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.status[40].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[40].component + "' != '" + 8307 + "'", - value.equals(BigInteger.valueOf(8307L))); + org.junit.Assert.assertTrue("'" + msg.status[40].component + "' != '" + 8307 + "'", value.equals(BigInteger.valueOf( 8307L ) ) ); } else { value = value.longValue(); expected = 8307L; @@ -1530,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.status[40].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[40].generic + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.status[40].generic + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -1540,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.status[40].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[40].specific + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.status[40].specific + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -1550,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.status[41].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[41].component + "' != '" + 43731 + "'", - value.equals(BigInteger.valueOf(43731L))); + org.junit.Assert.assertTrue("'" + msg.status[41].component + "' != '" + 43731 + "'", value.equals(BigInteger.valueOf( 43731L ) ) ); } else { value = value.longValue(); expected = 43731L; @@ -1560,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.status[41].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[41].generic + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.status[41].generic + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -1570,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.status[41].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[41].specific + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.status[41].specific + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -1580,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.status[42].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[42].component + "' != '" + 19357 + "'", - value.equals(BigInteger.valueOf(19357L))); + org.junit.Assert.assertTrue("'" + msg.status[42].component + "' != '" + 19357 + "'", value.equals(BigInteger.valueOf( 19357L ) ) ); } else { value = value.longValue(); expected = 19357L; @@ -1590,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.status[42].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[42].generic + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.status[42].generic + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -1600,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.status[42].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[42].specific + "' != '" + 169 + "'", - value.equals(BigInteger.valueOf(169L))); + org.junit.Assert.assertTrue("'" + msg.status[42].specific + "' != '" + 169 + "'", value.equals(BigInteger.valueOf( 169L ) ) ); } else { value = value.longValue(); expected = 169L; @@ -1610,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.status[43].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[43].component + "' != '" + 14086 + "'", - value.equals(BigInteger.valueOf(14086L))); + org.junit.Assert.assertTrue("'" + msg.status[43].component + "' != '" + 14086 + "'", value.equals(BigInteger.valueOf( 14086L ) ) ); } else { value = value.longValue(); expected = 14086L; @@ -1620,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.status[43].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[43].generic + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.status[43].generic + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -1630,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.status[43].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[43].specific + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.status[43].specific + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -1640,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.status[44].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[44].component + "' != '" + 21099 + "'", - value.equals(BigInteger.valueOf(21099L))); + org.junit.Assert.assertTrue("'" + msg.status[44].component + "' != '" + 21099 + "'", value.equals(BigInteger.valueOf( 21099L ) ) ); } else { value = value.longValue(); expected = 21099L; @@ -1650,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.status[44].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[44].generic + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.status[44].generic + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -1660,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.status[44].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[44].specific + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.status[44].specific + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -1670,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.status[45].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[45].component + "' != '" + 31411 + "'", - value.equals(BigInteger.valueOf(31411L))); + org.junit.Assert.assertTrue("'" + msg.status[45].component + "' != '" + 31411 + "'", value.equals(BigInteger.valueOf( 31411L ) ) ); } else { value = value.longValue(); expected = 31411L; @@ -1680,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.status[45].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[45].generic + "' != '" + 90 + "'", - value.equals(BigInteger.valueOf(90L))); + org.junit.Assert.assertTrue("'" + msg.status[45].generic + "' != '" + 90 + "'", value.equals(BigInteger.valueOf( 90L ) ) ); } else { value = value.longValue(); expected = 90L; @@ -1690,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.status[45].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[45].specific + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.status[45].specific + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -1700,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.status[46].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[46].component + "' != '" + 22556 + "'", - value.equals(BigInteger.valueOf(22556L))); + org.junit.Assert.assertTrue("'" + msg.status[46].component + "' != '" + 22556 + "'", value.equals(BigInteger.valueOf( 22556L ) ) ); } else { value = value.longValue(); expected = 22556L; @@ -1710,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.status[46].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[46].generic + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.status[46].generic + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -1720,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.status[46].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[46].specific + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.status[46].specific + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -1730,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.status[47].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[47].component + "' != '" + 18609 + "'", - value.equals(BigInteger.valueOf(18609L))); + org.junit.Assert.assertTrue("'" + msg.status[47].component + "' != '" + 18609 + "'", value.equals(BigInteger.valueOf( 18609L ) ) ); } else { value = value.longValue(); expected = 18609L; @@ -1740,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.status[47].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[47].generic + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.status[47].generic + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -1750,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.status[47].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[47].specific + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.status[47].specific + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -1760,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.status[48].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[48].component + "' != '" + 2964 + "'", - value.equals(BigInteger.valueOf(2964L))); + org.junit.Assert.assertTrue("'" + msg.status[48].component + "' != '" + 2964 + "'", value.equals(BigInteger.valueOf( 2964L ) ) ); } else { value = value.longValue(); expected = 2964L; @@ -1770,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.status[48].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[48].generic + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.status[48].generic + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -1780,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.status[48].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[48].specific + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.status[48].specific + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -1790,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.status[49].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[49].component + "' != '" + 23586 + "'", - value.equals(BigInteger.valueOf(23586L))); + org.junit.Assert.assertTrue("'" + msg.status[49].component + "' != '" + 23586 + "'", value.equals(BigInteger.valueOf( 23586L ) ) ); } else { value = value.longValue(); expected = 23586L; @@ -1800,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.status[49].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[49].generic + "' != '" + 204 + "'", - value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.status[49].generic + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -1810,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.status[49].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[49].specific + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.status[49].specific + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -1820,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.status[50].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[50].component + "' != '" + 25117 + "'", - value.equals(BigInteger.valueOf(25117L))); + org.junit.Assert.assertTrue("'" + msg.status[50].component + "' != '" + 25117 + "'", value.equals(BigInteger.valueOf( 25117L ) ) ); } else { value = value.longValue(); expected = 25117L; @@ -1830,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.status[50].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[50].generic + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.status[50].generic + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -1840,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.status[50].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[50].specific + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.status[50].specific + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -1850,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.status[51].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[51].component + "' != '" + 24454 + "'", - value.equals(BigInteger.valueOf(24454L))); + org.junit.Assert.assertTrue("'" + msg.status[51].component + "' != '" + 24454 + "'", value.equals(BigInteger.valueOf( 24454L ) ) ); } else { value = value.longValue(); expected = 24454L; @@ -1860,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.status[51].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[51].generic + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.status[51].generic + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1870,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.status[51].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[51].specific + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.status[51].specific + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -1880,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.status[52].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[52].component + "' != '" + 5312 + "'", - value.equals(BigInteger.valueOf(5312L))); + org.junit.Assert.assertTrue("'" + msg.status[52].component + "' != '" + 5312 + "'", value.equals(BigInteger.valueOf( 5312L ) ) ); } else { value = value.longValue(); expected = 5312L; @@ -1890,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.status[52].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[52].generic + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.status[52].generic + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -1900,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.status[52].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[52].specific + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.status[52].specific + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -1910,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.status[53].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[53].component + "' != '" + 46175 + "'", - value.equals(BigInteger.valueOf(46175L))); + org.junit.Assert.assertTrue("'" + msg.status[53].component + "' != '" + 46175 + "'", value.equals(BigInteger.valueOf( 46175L ) ) ); } else { value = value.longValue(); expected = 46175L; @@ -1920,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.status[53].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[53].generic + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.status[53].generic + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -1930,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.status[53].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[53].specific + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.status[53].specific + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -1940,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.status[54].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[54].component + "' != '" + 19386 + "'", - value.equals(BigInteger.valueOf(19386L))); + org.junit.Assert.assertTrue("'" + msg.status[54].component + "' != '" + 19386 + "'", value.equals(BigInteger.valueOf( 19386L ) ) ); } else { value = value.longValue(); expected = 19386L; @@ -1950,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.status[54].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[54].generic + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.status[54].generic + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -1960,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.status[54].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[54].specific + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.status[54].specific + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -1970,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.status[55].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[55].component + "' != '" + 34205 + "'", - value.equals(BigInteger.valueOf(34205L))); + org.junit.Assert.assertTrue("'" + msg.status[55].component + "' != '" + 34205 + "'", value.equals(BigInteger.valueOf( 34205L ) ) ); } else { value = value.longValue(); expected = 34205L; @@ -1980,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.status[55].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[55].generic + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.status[55].generic + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1990,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.status[55].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[55].specific + "' != '" + 149 + "'", - value.equals(BigInteger.valueOf(149L))); + org.junit.Assert.assertTrue("'" + msg.status[55].specific + "' != '" + 149 + "'", value.equals(BigInteger.valueOf( 149L ) ) ); } else { value = value.longValue(); expected = 149L; @@ -2000,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.status[56].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[56].component + "' != '" + 3612 + "'", - value.equals(BigInteger.valueOf(3612L))); + org.junit.Assert.assertTrue("'" + msg.status[56].component + "' != '" + 3612 + "'", value.equals(BigInteger.valueOf( 3612L ) ) ); } else { value = value.longValue(); expected = 3612L; @@ -2010,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.status[56].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[56].generic + "' != '" + 185 + "'", - value.equals(BigInteger.valueOf(185L))); + org.junit.Assert.assertTrue("'" + msg.status[56].generic + "' != '" + 185 + "'", value.equals(BigInteger.valueOf( 185L ) ) ); } else { value = value.longValue(); expected = 185L; @@ -2020,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.status[56].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[56].specific + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.status[56].specific + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -2030,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.status[57].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[57].component + "' != '" + 61285 + "'", - value.equals(BigInteger.valueOf(61285L))); + org.junit.Assert.assertTrue("'" + msg.status[57].component + "' != '" + 61285 + "'", value.equals(BigInteger.valueOf( 61285L ) ) ); } else { value = value.longValue(); expected = 61285L; @@ -2040,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.status[57].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[57].generic + "' != '" + 74 + "'", - value.equals(BigInteger.valueOf(74L))); + org.junit.Assert.assertTrue("'" + msg.status[57].generic + "' != '" + 74 + "'", value.equals(BigInteger.valueOf( 74L ) ) ); } else { value = value.longValue(); expected = 74L; @@ -2050,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.status[57].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[57].specific + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.status[57].specific + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -2060,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.status[58].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[58].component + "' != '" + 7925 + "'", - value.equals(BigInteger.valueOf(7925L))); + org.junit.Assert.assertTrue("'" + msg.status[58].component + "' != '" + 7925 + "'", value.equals(BigInteger.valueOf( 7925L ) ) ); } else { value = value.longValue(); expected = 7925L; @@ -2070,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.status[58].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[58].generic + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.status[58].generic + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -2080,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.status[58].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[58].specific + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.status[58].specific + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -2090,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.status[59].component; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[59].component + "' != '" + 54414 + "'", - value.equals(BigInteger.valueOf(54414L))); + org.junit.Assert.assertTrue("'" + msg.status[59].component + "' != '" + 54414 + "'", value.equals(BigInteger.valueOf( 54414L ) ) ); } else { value = value.longValue(); expected = 54414L; @@ -2100,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.status[59].generic; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[59].generic + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.status[59].generic + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -2110,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.status[59].specific; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.status[59].specific + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.status[59].specific + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -2120,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.uptime; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uptime + "' != '" + 1657804265 + "'", - value.equals(BigInteger.valueOf(1657804265L))); + org.junit.Assert.assertTrue("'" + msg.uptime + "' != '" + 1657804265 + "'", value.equals(BigInteger.valueOf( 1657804265L ) ) ); } else { value = value.longValue(); expected = 1657804265L; diff --git a/java/test/auto_check_sbp_system_system_structsTest.java b/java/test/auto_check_sbp_system_system_structsTest.java index 6cc130851..58ac395a7 100644 --- a/java/test/auto_check_sbp_system_system_structsTest.java +++ b/java/test/auto_check_sbp_system_system_structsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,10 +9,19 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_system_structs.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/system/test_system_structs.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; + +import org.json.JSONObject; + +import com.swiftnav.sbp.SBPMessage; + public class auto_check_sbp_system_system_structsTest { diff --git a/java/test/auto_check_sbp_telemetry_MsgTelSvTest.java b/java/test/auto_check_sbp_telemetry_MsgTelSvTest.java index 4ff1dc2b5..cbed52513 100644 --- a/java/test/auto_check_sbp_telemetry_MsgTelSvTest.java +++ b/java/test/auto_check_sbp_telemetry_MsgTelSvTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/telemetry/test_MsgTelSv.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/telemetry/test_MsgTelSv.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.telemetry.MsgTelSv; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_telemetry_MsgTelSvTest { @@ -27,22 +32,17 @@ public class auto_check_sbp_telemetry_MsgTelSvTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_telemetry_MsgTelSvTest.test1"); - byte[] payload = - new byte[] { - (byte) 175, (byte) 8, (byte) 208, (byte) 221, (byte) 62, (byte) 24, (byte) 16, - (byte) 1, (byte) 40, (byte) 50, (byte) 5, (byte) 226, (byte) 255, (byte) 1, - (byte) 0, (byte) 1, (byte) 1, (byte) 1, (byte) 33, (byte) 12, - }; - SBPMessage sbp = new SBPMessage(0x2694, 0x120, payload); - MsgTelSv msg = new MsgTelSv(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_telemetry_MsgTelSvTest.test1"); + byte[] payload = new byte[] {(byte)175,(byte)8,(byte)208,(byte)221,(byte)62,(byte)24,(byte)16,(byte)1,(byte)40,(byte)50,(byte)5,(byte)226,(byte)255,(byte)1,(byte)0,(byte)1,(byte)1,(byte)1,(byte)33,(byte)12, }; + SBPMessage sbp = new SBPMessage( 0x2694, 0x120, payload ); + MsgTelSv msg = new MsgTelSv( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.n_obs; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.n_obs + "' != '" + 16 + "'", value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.n_obs + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -50,9 +50,7 @@ public void test1() throws Throwable { } value = msg.origin_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.origin_flags + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.origin_flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -60,9 +58,7 @@ public void test1() throws Throwable { } value = msg.sv_tel[0].availability_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sv_tel[0].availability_flags + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.sv_tel[0].availability_flags + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -70,9 +66,7 @@ public void test1() throws Throwable { } value = msg.sv_tel[0].az; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sv_tel[0].az + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.sv_tel[0].az + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -80,9 +74,7 @@ public void test1() throws Throwable { } value = msg.sv_tel[0].correction_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sv_tel[0].correction_flags + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sv_tel[0].correction_flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -90,9 +82,7 @@ public void test1() throws Throwable { } value = msg.sv_tel[0].el; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sv_tel[0].el + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.sv_tel[0].el + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -100,9 +90,7 @@ public void test1() throws Throwable { } value = msg.sv_tel[0].ephemeris_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sv_tel[0].ephemeris_flags + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sv_tel[0].ephemeris_flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -110,9 +98,7 @@ public void test1() throws Throwable { } value = msg.sv_tel[0].outlier_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sv_tel[0].outlier_flags + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sv_tel[0].outlier_flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -120,9 +106,7 @@ public void test1() throws Throwable { } value = msg.sv_tel[0].phase_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sv_tel[0].phase_residual + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sv_tel[0].phase_residual + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -130,9 +114,7 @@ public void test1() throws Throwable { } value = msg.sv_tel[0].pseudorange_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sv_tel[0].pseudorange_residual + "' != '" + -30 + "'", - value.equals(BigInteger.valueOf(-30L))); + org.junit.Assert.assertTrue("'" + msg.sv_tel[0].pseudorange_residual + "' != '" + -30 + "'", value.equals(BigInteger.valueOf( -30L ) ) ); } else { value = value.longValue(); expected = -30L; @@ -140,9 +122,7 @@ public void test1() throws Throwable { } value = msg.sv_tel[0].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sv_tel[0].sid.code + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.sv_tel[0].sid.code + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -150,9 +130,7 @@ public void test1() throws Throwable { } value = msg.sv_tel[0].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sv_tel[0].sid.sat + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.sv_tel[0].sid.sat + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -160,9 +138,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 406773200 + "'", - value.equals(BigInteger.valueOf(406773200L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 406773200 + "'", value.equals(BigInteger.valueOf( 406773200L ) ) ); } else { value = value.longValue(); expected = 406773200L; @@ -170,8 +146,7 @@ public void test1() throws Throwable { } value = msg.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.wn + "' != '" + 2223 + "'", value.equals(BigInteger.valueOf(2223L))); + org.junit.Assert.assertTrue("'" + msg.wn + "' != '" + 2223 + "'", value.equals(BigInteger.valueOf( 2223L ) ) ); } else { value = value.longValue(); expected = 2223L; diff --git a/java/test/auto_check_sbp_telemetry_acquisition_structsTest.java b/java/test/auto_check_sbp_telemetry_acquisition_structsTest.java index cd1998283..a09692e82 100644 --- a/java/test/auto_check_sbp_telemetry_acquisition_structsTest.java +++ b/java/test/auto_check_sbp_telemetry_acquisition_structsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,11 +9,19 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/acquisition/test_acquisition_structs.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/acquisition/test_acquisition_structs.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; + +import org.json.JSONObject; + +import com.swiftnav.sbp.SBPMessage; + public class auto_check_sbp_telemetry_acquisition_structsTest { diff --git a/java/test/auto_check_sbp_telemetry_telemetry_structsTest.java b/java/test/auto_check_sbp_telemetry_telemetry_structsTest.java index 8d5ddce7d..6b619f9f1 100644 --- a/java/test/auto_check_sbp_telemetry_telemetry_structsTest.java +++ b/java/test/auto_check_sbp_telemetry_telemetry_structsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,11 +9,19 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/telemetry/test_telemetry_structs.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/telemetry/test_telemetry_structs.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; + +import org.json.JSONObject; + +import com.swiftnav.sbp.SBPMessage; + public class auto_check_sbp_telemetry_telemetry_structsTest { diff --git a/java/test/auto_check_sbp_tracking_MsgMeasurementStateTest.java b/java/test/auto_check_sbp_tracking_MsgMeasurementStateTest.java index 114483b45..86a793d99 100644 --- a/java/test/auto_check_sbp_tracking_MsgMeasurementStateTest.java +++ b/java/test/auto_check_sbp_tracking_MsgMeasurementStateTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/tracking/test_MsgMeasurementState.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/tracking/test_MsgMeasurementState.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.tracking.MsgMeasurementState; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_tracking_MsgMeasurementStateTest { @@ -30,256 +34,15 @@ public class auto_check_sbp_tracking_MsgMeasurementStateTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgMeasurementStateTest.test1"); - byte[] payload = - new byte[] { - (byte) 29, - (byte) 0, - (byte) 162, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 27, - (byte) 0, - (byte) 201, - (byte) 20, - (byte) 0, - (byte) 168, - (byte) 32, - (byte) 0, - (byte) 184, - (byte) 15, - (byte) 0, - (byte) 187, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 18, - (byte) 0, - (byte) 210, - (byte) 16, - (byte) 0, - (byte) 167, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 23, - (byte) 0, - (byte) 213, - (byte) 10, - (byte) 0, - (byte) 223, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 131, - (byte) 2, - (byte) 202, - (byte) 27, - (byte) 1, - (byte) 192, - (byte) 15, - (byte) 1, - (byte) 165, - (byte) 29, - (byte) 1, - (byte) 146, - (byte) 32, - (byte) 1, - (byte) 170, - (byte) 18, - (byte) 1, - (byte) 201, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 23, - (byte) 1, - (byte) 212, - (byte) 10, - (byte) 1, - (byte) 205, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 96, - (byte) 3, - (byte) 230, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 101, - (byte) 3, - (byte) 214, - (byte) 103, - (byte) 3, - (byte) 212, - (byte) 104, - (byte) 3, - (byte) 209, - (byte) 106, - (byte) 3, - (byte) 157, - (byte) 102, - (byte) 3, - (byte) 230, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 101, - (byte) 4, - (byte) 189, - (byte) 96, - (byte) 4, - (byte) 207, - (byte) 106, - (byte) 4, - (byte) 164, - (byte) 104, - (byte) 4, - (byte) 193, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 102, - (byte) 4, - (byte) 208, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 27, - (byte) 12, - (byte) 212, - (byte) 29, - (byte) 12, - (byte) 161, - (byte) 32, - (byte) 12, - (byte) 216, - (byte) 30, - (byte) 12, - (byte) 216, - (byte) 20, - (byte) 12, - (byte) 178, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 36, - (byte) 14, - (byte) 203, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 5, - (byte) 14, - (byte) 158, - (byte) 4, - (byte) 14, - (byte) 194, - (byte) 11, - (byte) 14, - (byte) 192, - (byte) 9, - (byte) 14, - (byte) 207, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 9, - (byte) 20, - (byte) 218, - (byte) 5, - (byte) 20, - (byte) 176, - (byte) 36, - (byte) 20, - (byte) 217, - (byte) 11, - (byte) 20, - (byte) 200, - (byte) 4, - (byte) 20, - (byte) 205, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - }; - SBPMessage sbp = new SBPMessage(0x79CF, 0x61, payload); - MsgMeasurementState msg = new MsgMeasurementState(sbp); + byte[] payload = new byte[] {(byte)29,(byte)0,(byte)162,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)27,(byte)0,(byte)201,(byte)20,(byte)0,(byte)168,(byte)32,(byte)0,(byte)184,(byte)15,(byte)0,(byte)187,(byte)0,(byte)0,(byte)0,(byte)18,(byte)0,(byte)210,(byte)16,(byte)0,(byte)167,(byte)0,(byte)0,(byte)0,(byte)23,(byte)0,(byte)213,(byte)10,(byte)0,(byte)223,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)131,(byte)2,(byte)202,(byte)27,(byte)1,(byte)192,(byte)15,(byte)1,(byte)165,(byte)29,(byte)1,(byte)146,(byte)32,(byte)1,(byte)170,(byte)18,(byte)1,(byte)201,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)23,(byte)1,(byte)212,(byte)10,(byte)1,(byte)205,(byte)0,(byte)0,(byte)0,(byte)96,(byte)3,(byte)230,(byte)0,(byte)0,(byte)0,(byte)101,(byte)3,(byte)214,(byte)103,(byte)3,(byte)212,(byte)104,(byte)3,(byte)209,(byte)106,(byte)3,(byte)157,(byte)102,(byte)3,(byte)230,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)101,(byte)4,(byte)189,(byte)96,(byte)4,(byte)207,(byte)106,(byte)4,(byte)164,(byte)104,(byte)4,(byte)193,(byte)0,(byte)0,(byte)0,(byte)102,(byte)4,(byte)208,(byte)0,(byte)0,(byte)0,(byte)27,(byte)12,(byte)212,(byte)29,(byte)12,(byte)161,(byte)32,(byte)12,(byte)216,(byte)30,(byte)12,(byte)216,(byte)20,(byte)12,(byte)178,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)36,(byte)14,(byte)203,(byte)0,(byte)0,(byte)0,(byte)5,(byte)14,(byte)158,(byte)4,(byte)14,(byte)194,(byte)11,(byte)14,(byte)192,(byte)9,(byte)14,(byte)207,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)9,(byte)20,(byte)218,(byte)5,(byte)20,(byte)176,(byte)36,(byte)20,(byte)217,(byte)11,(byte)20,(byte)200,(byte)4,(byte)20,(byte)205,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0, }; + SBPMessage sbp = new SBPMessage( 0x79CF, 0x61, payload ); + MsgMeasurementState msg = new MsgMeasurementState( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.states[0].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].cn0 + "' != '" + 162 + "'", - value.equals(BigInteger.valueOf(162L))); + org.junit.Assert.assertTrue("'" + msg.states[0].cn0 + "' != '" + 162 + "'", value.equals(BigInteger.valueOf( 162L ) ) ); } else { value = value.longValue(); expected = 162L; @@ -287,9 +50,7 @@ public void test1() throws Throwable { } value = msg.states[0].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -297,9 +58,7 @@ public void test1() throws Throwable { } value = msg.states[0].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].mesid.sat + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.states[0].mesid.sat + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -307,9 +66,7 @@ public void test1() throws Throwable { } value = msg.states[1].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -317,9 +74,7 @@ public void test1() throws Throwable { } value = msg.states[1].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -327,9 +82,7 @@ public void test1() throws Throwable { } value = msg.states[1].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -337,9 +90,7 @@ public void test1() throws Throwable { } value = msg.states[2].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -347,9 +98,7 @@ public void test1() throws Throwable { } value = msg.states[2].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -357,9 +106,7 @@ public void test1() throws Throwable { } value = msg.states[2].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -367,9 +114,7 @@ public void test1() throws Throwable { } value = msg.states[3].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].cn0 + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.states[3].cn0 + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -377,9 +122,7 @@ public void test1() throws Throwable { } value = msg.states[3].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -387,9 +130,7 @@ public void test1() throws Throwable { } value = msg.states[3].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].mesid.sat + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.states[3].mesid.sat + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -397,9 +138,7 @@ public void test1() throws Throwable { } value = msg.states[4].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].cn0 + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.states[4].cn0 + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -407,9 +146,7 @@ public void test1() throws Throwable { } value = msg.states[4].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -417,9 +154,7 @@ public void test1() throws Throwable { } value = msg.states[4].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].mesid.sat + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.states[4].mesid.sat + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -427,9 +162,7 @@ public void test1() throws Throwable { } value = msg.states[5].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].cn0 + "' != '" + 184 + "'", - value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.states[5].cn0 + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -437,9 +170,7 @@ public void test1() throws Throwable { } value = msg.states[5].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -447,9 +178,7 @@ public void test1() throws Throwable { } value = msg.states[5].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].mesid.sat + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.states[5].mesid.sat + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -457,9 +186,7 @@ public void test1() throws Throwable { } value = msg.states[6].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].cn0 + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.states[6].cn0 + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -467,9 +194,7 @@ public void test1() throws Throwable { } value = msg.states[6].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -477,9 +202,7 @@ public void test1() throws Throwable { } value = msg.states[6].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].mesid.sat + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.states[6].mesid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -487,9 +210,7 @@ public void test1() throws Throwable { } value = msg.states[7].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -497,9 +218,7 @@ public void test1() throws Throwable { } value = msg.states[7].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -507,9 +226,7 @@ public void test1() throws Throwable { } value = msg.states[7].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -517,9 +234,7 @@ public void test1() throws Throwable { } value = msg.states[8].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].cn0 + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.states[8].cn0 + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -527,9 +242,7 @@ public void test1() throws Throwable { } value = msg.states[8].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -537,9 +250,7 @@ public void test1() throws Throwable { } value = msg.states[8].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].mesid.sat + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.states[8].mesid.sat + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -547,9 +258,7 @@ public void test1() throws Throwable { } value = msg.states[9].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].cn0 + "' != '" + 167 + "'", - value.equals(BigInteger.valueOf(167L))); + org.junit.Assert.assertTrue("'" + msg.states[9].cn0 + "' != '" + 167 + "'", value.equals(BigInteger.valueOf( 167L ) ) ); } else { value = value.longValue(); expected = 167L; @@ -557,9 +266,7 @@ public void test1() throws Throwable { } value = msg.states[9].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -567,9 +274,7 @@ public void test1() throws Throwable { } value = msg.states[9].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].mesid.sat + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.states[9].mesid.sat + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -577,9 +282,7 @@ public void test1() throws Throwable { } value = msg.states[10].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -587,9 +290,7 @@ public void test1() throws Throwable { } value = msg.states[10].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -597,9 +298,7 @@ public void test1() throws Throwable { } value = msg.states[10].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -607,9 +306,7 @@ public void test1() throws Throwable { } value = msg.states[11].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[11].cn0 + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.states[11].cn0 + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -617,9 +314,7 @@ public void test1() throws Throwable { } value = msg.states[11].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[11].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[11].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -627,9 +322,7 @@ public void test1() throws Throwable { } value = msg.states[11].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[11].mesid.sat + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.states[11].mesid.sat + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -637,9 +330,7 @@ public void test1() throws Throwable { } value = msg.states[12].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[12].cn0 + "' != '" + 223 + "'", - value.equals(BigInteger.valueOf(223L))); + org.junit.Assert.assertTrue("'" + msg.states[12].cn0 + "' != '" + 223 + "'", value.equals(BigInteger.valueOf( 223L ) ) ); } else { value = value.longValue(); expected = 223L; @@ -647,9 +338,7 @@ public void test1() throws Throwable { } value = msg.states[12].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[12].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[12].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -657,9 +346,7 @@ public void test1() throws Throwable { } value = msg.states[12].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[12].mesid.sat + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.states[12].mesid.sat + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -667,9 +354,7 @@ public void test1() throws Throwable { } value = msg.states[13].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[13].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[13].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -677,9 +362,7 @@ public void test1() throws Throwable { } value = msg.states[13].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[13].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[13].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -687,9 +370,7 @@ public void test1() throws Throwable { } value = msg.states[13].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[13].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[13].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -697,9 +378,7 @@ public void test1() throws Throwable { } value = msg.states[14].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[14].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[14].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -707,9 +386,7 @@ public void test1() throws Throwable { } value = msg.states[14].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[14].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[14].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -717,9 +394,7 @@ public void test1() throws Throwable { } value = msg.states[14].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[14].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[14].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -727,9 +402,7 @@ public void test1() throws Throwable { } value = msg.states[15].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[15].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[15].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -737,9 +410,7 @@ public void test1() throws Throwable { } value = msg.states[15].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[15].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[15].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -747,9 +418,7 @@ public void test1() throws Throwable { } value = msg.states[15].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[15].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[15].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -757,9 +426,7 @@ public void test1() throws Throwable { } value = msg.states[16].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[16].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[16].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -767,9 +434,7 @@ public void test1() throws Throwable { } value = msg.states[16].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[16].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[16].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -777,9 +442,7 @@ public void test1() throws Throwable { } value = msg.states[16].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[16].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[16].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -787,9 +450,7 @@ public void test1() throws Throwable { } value = msg.states[17].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[17].cn0 + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.states[17].cn0 + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -797,9 +458,7 @@ public void test1() throws Throwable { } value = msg.states[17].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[17].mesid.code + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.states[17].mesid.code + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -807,9 +466,7 @@ public void test1() throws Throwable { } value = msg.states[17].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[17].mesid.sat + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.states[17].mesid.sat + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -817,9 +474,7 @@ public void test1() throws Throwable { } value = msg.states[18].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[18].cn0 + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.states[18].cn0 + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -827,9 +482,7 @@ public void test1() throws Throwable { } value = msg.states[18].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[18].mesid.code + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[18].mesid.code + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -837,9 +490,7 @@ public void test1() throws Throwable { } value = msg.states[18].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[18].mesid.sat + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.states[18].mesid.sat + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -847,9 +498,7 @@ public void test1() throws Throwable { } value = msg.states[19].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[19].cn0 + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.states[19].cn0 + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -857,9 +506,7 @@ public void test1() throws Throwable { } value = msg.states[19].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[19].mesid.code + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[19].mesid.code + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -867,9 +514,7 @@ public void test1() throws Throwable { } value = msg.states[19].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[19].mesid.sat + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.states[19].mesid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -877,9 +522,7 @@ public void test1() throws Throwable { } value = msg.states[20].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[20].cn0 + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.states[20].cn0 + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -887,9 +530,7 @@ public void test1() throws Throwable { } value = msg.states[20].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[20].mesid.code + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[20].mesid.code + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -897,9 +538,7 @@ public void test1() throws Throwable { } value = msg.states[20].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[20].mesid.sat + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.states[20].mesid.sat + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -907,9 +546,7 @@ public void test1() throws Throwable { } value = msg.states[21].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[21].cn0 + "' != '" + 170 + "'", - value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.states[21].cn0 + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -917,9 +554,7 @@ public void test1() throws Throwable { } value = msg.states[21].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[21].mesid.code + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[21].mesid.code + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -927,9 +562,7 @@ public void test1() throws Throwable { } value = msg.states[21].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[21].mesid.sat + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.states[21].mesid.sat + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -937,9 +570,7 @@ public void test1() throws Throwable { } value = msg.states[22].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[22].cn0 + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.states[22].cn0 + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -947,9 +578,7 @@ public void test1() throws Throwable { } value = msg.states[22].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[22].mesid.code + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[22].mesid.code + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -957,9 +586,7 @@ public void test1() throws Throwable { } value = msg.states[22].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[22].mesid.sat + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.states[22].mesid.sat + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -967,9 +594,7 @@ public void test1() throws Throwable { } value = msg.states[23].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[23].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[23].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -977,9 +602,7 @@ public void test1() throws Throwable { } value = msg.states[23].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[23].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[23].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -987,9 +610,7 @@ public void test1() throws Throwable { } value = msg.states[23].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[23].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[23].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -997,9 +618,7 @@ public void test1() throws Throwable { } value = msg.states[24].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[24].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[24].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1007,9 +626,7 @@ public void test1() throws Throwable { } value = msg.states[24].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[24].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[24].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1017,9 +634,7 @@ public void test1() throws Throwable { } value = msg.states[24].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[24].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[24].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1027,9 +642,7 @@ public void test1() throws Throwable { } value = msg.states[25].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[25].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[25].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1037,9 +650,7 @@ public void test1() throws Throwable { } value = msg.states[25].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[25].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[25].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1047,9 +658,7 @@ public void test1() throws Throwable { } value = msg.states[25].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[25].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[25].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1057,9 +666,7 @@ public void test1() throws Throwable { } value = msg.states[26].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[26].cn0 + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.states[26].cn0 + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -1067,9 +674,7 @@ public void test1() throws Throwable { } value = msg.states[26].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[26].mesid.code + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[26].mesid.code + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1077,9 +682,7 @@ public void test1() throws Throwable { } value = msg.states[26].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[26].mesid.sat + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.states[26].mesid.sat + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1087,9 +690,7 @@ public void test1() throws Throwable { } value = msg.states[27].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[27].cn0 + "' != '" + 205 + "'", - value.equals(BigInteger.valueOf(205L))); + org.junit.Assert.assertTrue("'" + msg.states[27].cn0 + "' != '" + 205 + "'", value.equals(BigInteger.valueOf( 205L ) ) ); } else { value = value.longValue(); expected = 205L; @@ -1097,9 +698,7 @@ public void test1() throws Throwable { } value = msg.states[27].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[27].mesid.code + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[27].mesid.code + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1107,9 +706,7 @@ public void test1() throws Throwable { } value = msg.states[27].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[27].mesid.sat + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.states[27].mesid.sat + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -1117,9 +714,7 @@ public void test1() throws Throwable { } value = msg.states[28].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[28].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[28].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1127,9 +722,7 @@ public void test1() throws Throwable { } value = msg.states[28].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[28].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[28].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1137,9 +730,7 @@ public void test1() throws Throwable { } value = msg.states[28].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[28].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[28].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1147,9 +738,7 @@ public void test1() throws Throwable { } value = msg.states[29].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[29].cn0 + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.states[29].cn0 + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1157,9 +746,7 @@ public void test1() throws Throwable { } value = msg.states[29].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[29].mesid.code + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[29].mesid.code + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1167,9 +754,7 @@ public void test1() throws Throwable { } value = msg.states[29].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[29].mesid.sat + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.states[29].mesid.sat + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -1177,9 +762,7 @@ public void test1() throws Throwable { } value = msg.states[30].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[30].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[30].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1187,9 +770,7 @@ public void test1() throws Throwable { } value = msg.states[30].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[30].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[30].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1197,9 +778,7 @@ public void test1() throws Throwable { } value = msg.states[30].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[30].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[30].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1207,9 +786,7 @@ public void test1() throws Throwable { } value = msg.states[31].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[31].cn0 + "' != '" + 214 + "'", - value.equals(BigInteger.valueOf(214L))); + org.junit.Assert.assertTrue("'" + msg.states[31].cn0 + "' != '" + 214 + "'", value.equals(BigInteger.valueOf( 214L ) ) ); } else { value = value.longValue(); expected = 214L; @@ -1217,9 +794,7 @@ public void test1() throws Throwable { } value = msg.states[31].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[31].mesid.code + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[31].mesid.code + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1227,9 +802,7 @@ public void test1() throws Throwable { } value = msg.states[31].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[31].mesid.sat + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.states[31].mesid.sat + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -1237,9 +810,7 @@ public void test1() throws Throwable { } value = msg.states[32].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[32].cn0 + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.states[32].cn0 + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -1247,9 +818,7 @@ public void test1() throws Throwable { } value = msg.states[32].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[32].mesid.code + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[32].mesid.code + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1257,9 +826,7 @@ public void test1() throws Throwable { } value = msg.states[32].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[32].mesid.sat + "' != '" + 103 + "'", - value.equals(BigInteger.valueOf(103L))); + org.junit.Assert.assertTrue("'" + msg.states[32].mesid.sat + "' != '" + 103 + "'", value.equals(BigInteger.valueOf( 103L ) ) ); } else { value = value.longValue(); expected = 103L; @@ -1267,9 +834,7 @@ public void test1() throws Throwable { } value = msg.states[33].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[33].cn0 + "' != '" + 209 + "'", - value.equals(BigInteger.valueOf(209L))); + org.junit.Assert.assertTrue("'" + msg.states[33].cn0 + "' != '" + 209 + "'", value.equals(BigInteger.valueOf( 209L ) ) ); } else { value = value.longValue(); expected = 209L; @@ -1277,9 +842,7 @@ public void test1() throws Throwable { } value = msg.states[33].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[33].mesid.code + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[33].mesid.code + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1287,9 +850,7 @@ public void test1() throws Throwable { } value = msg.states[33].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[33].mesid.sat + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.states[33].mesid.sat + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -1297,9 +858,7 @@ public void test1() throws Throwable { } value = msg.states[34].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[34].cn0 + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.states[34].cn0 + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -1307,9 +866,7 @@ public void test1() throws Throwable { } value = msg.states[34].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[34].mesid.code + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[34].mesid.code + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1317,9 +874,7 @@ public void test1() throws Throwable { } value = msg.states[34].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[34].mesid.sat + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.states[34].mesid.sat + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -1327,9 +882,7 @@ public void test1() throws Throwable { } value = msg.states[35].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[35].cn0 + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.states[35].cn0 + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1337,9 +890,7 @@ public void test1() throws Throwable { } value = msg.states[35].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[35].mesid.code + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[35].mesid.code + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1347,9 +898,7 @@ public void test1() throws Throwable { } value = msg.states[35].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[35].mesid.sat + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.states[35].mesid.sat + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -1357,9 +906,7 @@ public void test1() throws Throwable { } value = msg.states[36].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[36].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[36].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1367,9 +914,7 @@ public void test1() throws Throwable { } value = msg.states[36].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[36].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[36].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1377,9 +922,7 @@ public void test1() throws Throwable { } value = msg.states[36].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[36].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[36].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1387,9 +930,7 @@ public void test1() throws Throwable { } value = msg.states[37].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[37].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[37].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1397,9 +938,7 @@ public void test1() throws Throwable { } value = msg.states[37].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[37].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[37].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1407,9 +946,7 @@ public void test1() throws Throwable { } value = msg.states[37].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[37].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[37].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1417,9 +954,7 @@ public void test1() throws Throwable { } value = msg.states[38].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[38].cn0 + "' != '" + 189 + "'", - value.equals(BigInteger.valueOf(189L))); + org.junit.Assert.assertTrue("'" + msg.states[38].cn0 + "' != '" + 189 + "'", value.equals(BigInteger.valueOf( 189L ) ) ); } else { value = value.longValue(); expected = 189L; @@ -1427,9 +962,7 @@ public void test1() throws Throwable { } value = msg.states[38].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[38].mesid.code + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.states[38].mesid.code + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1437,9 +970,7 @@ public void test1() throws Throwable { } value = msg.states[38].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[38].mesid.sat + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.states[38].mesid.sat + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -1447,9 +978,7 @@ public void test1() throws Throwable { } value = msg.states[39].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[39].cn0 + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.states[39].cn0 + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -1457,9 +986,7 @@ public void test1() throws Throwable { } value = msg.states[39].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[39].mesid.code + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.states[39].mesid.code + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1467,9 +994,7 @@ public void test1() throws Throwable { } value = msg.states[39].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[39].mesid.sat + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.states[39].mesid.sat + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -1477,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.states[40].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[40].cn0 + "' != '" + 164 + "'", - value.equals(BigInteger.valueOf(164L))); + org.junit.Assert.assertTrue("'" + msg.states[40].cn0 + "' != '" + 164 + "'", value.equals(BigInteger.valueOf( 164L ) ) ); } else { value = value.longValue(); expected = 164L; @@ -1487,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.states[40].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[40].mesid.code + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.states[40].mesid.code + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1497,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.states[40].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[40].mesid.sat + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.states[40].mesid.sat + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -1507,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.states[41].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[41].cn0 + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.states[41].cn0 + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -1517,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.states[41].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[41].mesid.code + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.states[41].mesid.code + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1527,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.states[41].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[41].mesid.sat + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.states[41].mesid.sat + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -1537,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.states[42].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[42].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[42].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1547,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.states[42].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[42].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[42].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1557,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.states[42].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[42].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[42].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1567,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.states[43].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[43].cn0 + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.states[43].cn0 + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -1577,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.states[43].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[43].mesid.code + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.states[43].mesid.code + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1587,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.states[43].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[43].mesid.sat + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.states[43].mesid.sat + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -1597,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.states[44].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[44].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[44].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1607,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.states[44].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[44].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[44].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1617,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.states[44].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[44].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[44].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1627,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.states[45].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[45].cn0 + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.states[45].cn0 + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -1637,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.states[45].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[45].mesid.code + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.states[45].mesid.code + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1647,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.states[45].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[45].mesid.sat + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.states[45].mesid.sat + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -1657,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.states[46].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[46].cn0 + "' != '" + 161 + "'", - value.equals(BigInteger.valueOf(161L))); + org.junit.Assert.assertTrue("'" + msg.states[46].cn0 + "' != '" + 161 + "'", value.equals(BigInteger.valueOf( 161L ) ) ); } else { value = value.longValue(); expected = 161L; @@ -1667,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.states[46].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[46].mesid.code + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.states[46].mesid.code + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1677,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.states[46].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[46].mesid.sat + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.states[46].mesid.sat + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -1687,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.states[47].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[47].cn0 + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.states[47].cn0 + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -1697,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.states[47].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[47].mesid.code + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.states[47].mesid.code + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1707,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.states[47].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[47].mesid.sat + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.states[47].mesid.sat + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -1717,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.states[48].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[48].cn0 + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.states[48].cn0 + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -1727,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.states[48].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[48].mesid.code + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.states[48].mesid.code + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1737,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.states[48].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[48].mesid.sat + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.states[48].mesid.sat + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -1747,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.states[49].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[49].cn0 + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.states[49].cn0 + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -1757,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.states[49].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[49].mesid.code + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.states[49].mesid.code + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1767,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.states[49].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[49].mesid.sat + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.states[49].mesid.sat + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -1777,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.states[50].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[50].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[50].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1787,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.states[50].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[50].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[50].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1797,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.states[50].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[50].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[50].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1807,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.states[51].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[51].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[51].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1817,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.states[51].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[51].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[51].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1827,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.states[51].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[51].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[51].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1837,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.states[52].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[52].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[52].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1847,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.states[52].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[52].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[52].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1857,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.states[52].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[52].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[52].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1867,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.states[53].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[53].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[53].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1877,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.states[53].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[53].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[53].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1887,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.states[53].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[53].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[53].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1897,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.states[54].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[54].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[54].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1907,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.states[54].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[54].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[54].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1917,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.states[54].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[54].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[54].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1927,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.states[55].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[55].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[55].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1937,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.states[55].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[55].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[55].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1947,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.states[55].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[55].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[55].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1957,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.states[56].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[56].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[56].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1967,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.states[56].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[56].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[56].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1977,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.states[56].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[56].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[56].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1987,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.states[57].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[57].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[57].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1997,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.states[57].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[57].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[57].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2007,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.states[57].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[57].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[57].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2017,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.states[58].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[58].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[58].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2027,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.states[58].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[58].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[58].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2037,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.states[58].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[58].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[58].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2047,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.states[59].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[59].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[59].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2057,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.states[59].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[59].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[59].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2067,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.states[59].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[59].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[59].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2077,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.states[60].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[60].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[60].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2087,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.states[60].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[60].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[60].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2097,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.states[60].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[60].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[60].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2107,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.states[61].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[61].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[61].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2117,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.states[61].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[61].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[61].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2127,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.states[61].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[61].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[61].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2137,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.states[62].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[62].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[62].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2147,9 +1538,7 @@ public void test1() throws Throwable { } value = msg.states[62].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[62].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[62].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2157,9 +1546,7 @@ public void test1() throws Throwable { } value = msg.states[62].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[62].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[62].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2167,9 +1554,7 @@ public void test1() throws Throwable { } value = msg.states[63].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[63].cn0 + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.states[63].cn0 + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -2177,9 +1562,7 @@ public void test1() throws Throwable { } value = msg.states[63].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[63].mesid.code + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.states[63].mesid.code + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -2187,9 +1570,7 @@ public void test1() throws Throwable { } value = msg.states[63].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[63].mesid.sat + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.states[63].mesid.sat + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -2197,9 +1578,7 @@ public void test1() throws Throwable { } value = msg.states[64].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[64].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[64].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2207,9 +1586,7 @@ public void test1() throws Throwable { } value = msg.states[64].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[64].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[64].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2217,9 +1594,7 @@ public void test1() throws Throwable { } value = msg.states[64].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[64].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[64].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2227,9 +1602,7 @@ public void test1() throws Throwable { } value = msg.states[65].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[65].cn0 + "' != '" + 158 + "'", - value.equals(BigInteger.valueOf(158L))); + org.junit.Assert.assertTrue("'" + msg.states[65].cn0 + "' != '" + 158 + "'", value.equals(BigInteger.valueOf( 158L ) ) ); } else { value = value.longValue(); expected = 158L; @@ -2237,9 +1610,7 @@ public void test1() throws Throwable { } value = msg.states[65].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[65].mesid.code + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.states[65].mesid.code + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -2247,9 +1618,7 @@ public void test1() throws Throwable { } value = msg.states[65].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[65].mesid.sat + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.states[65].mesid.sat + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -2257,9 +1626,7 @@ public void test1() throws Throwable { } value = msg.states[66].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[66].cn0 + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.states[66].cn0 + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -2267,9 +1634,7 @@ public void test1() throws Throwable { } value = msg.states[66].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[66].mesid.code + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.states[66].mesid.code + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -2277,9 +1642,7 @@ public void test1() throws Throwable { } value = msg.states[66].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[66].mesid.sat + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.states[66].mesid.sat + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -2287,9 +1650,7 @@ public void test1() throws Throwable { } value = msg.states[67].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[67].cn0 + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.states[67].cn0 + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -2297,9 +1658,7 @@ public void test1() throws Throwable { } value = msg.states[67].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[67].mesid.code + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.states[67].mesid.code + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -2307,9 +1666,7 @@ public void test1() throws Throwable { } value = msg.states[67].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[67].mesid.sat + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.states[67].mesid.sat + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -2317,9 +1674,7 @@ public void test1() throws Throwable { } value = msg.states[68].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[68].cn0 + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.states[68].cn0 + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -2327,9 +1682,7 @@ public void test1() throws Throwable { } value = msg.states[68].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[68].mesid.code + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.states[68].mesid.code + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -2337,9 +1690,7 @@ public void test1() throws Throwable { } value = msg.states[68].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[68].mesid.sat + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.states[68].mesid.sat + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -2347,9 +1698,7 @@ public void test1() throws Throwable { } value = msg.states[69].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[69].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[69].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2357,9 +1706,7 @@ public void test1() throws Throwable { } value = msg.states[69].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[69].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[69].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2367,9 +1714,7 @@ public void test1() throws Throwable { } value = msg.states[69].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[69].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[69].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2377,9 +1722,7 @@ public void test1() throws Throwable { } value = msg.states[70].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[70].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[70].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2387,9 +1730,7 @@ public void test1() throws Throwable { } value = msg.states[70].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[70].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[70].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2397,9 +1738,7 @@ public void test1() throws Throwable { } value = msg.states[70].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[70].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[70].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2407,9 +1746,7 @@ public void test1() throws Throwable { } value = msg.states[71].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[71].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[71].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2417,9 +1754,7 @@ public void test1() throws Throwable { } value = msg.states[71].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[71].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[71].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2427,9 +1762,7 @@ public void test1() throws Throwable { } value = msg.states[71].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[71].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[71].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2437,9 +1770,7 @@ public void test1() throws Throwable { } value = msg.states[72].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[72].cn0 + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.states[72].cn0 + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -2447,9 +1778,7 @@ public void test1() throws Throwable { } value = msg.states[72].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[72].mesid.code + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.states[72].mesid.code + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -2457,9 +1786,7 @@ public void test1() throws Throwable { } value = msg.states[72].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[72].mesid.sat + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.states[72].mesid.sat + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -2467,9 +1794,7 @@ public void test1() throws Throwable { } value = msg.states[73].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[73].cn0 + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.states[73].cn0 + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -2477,9 +1802,7 @@ public void test1() throws Throwable { } value = msg.states[73].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[73].mesid.code + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.states[73].mesid.code + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -2487,9 +1810,7 @@ public void test1() throws Throwable { } value = msg.states[73].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[73].mesid.sat + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.states[73].mesid.sat + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -2497,9 +1818,7 @@ public void test1() throws Throwable { } value = msg.states[74].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[74].cn0 + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.states[74].cn0 + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -2507,9 +1826,7 @@ public void test1() throws Throwable { } value = msg.states[74].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[74].mesid.code + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.states[74].mesid.code + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -2517,9 +1834,7 @@ public void test1() throws Throwable { } value = msg.states[74].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[74].mesid.sat + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.states[74].mesid.sat + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -2527,9 +1842,7 @@ public void test1() throws Throwable { } value = msg.states[75].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[75].cn0 + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.states[75].cn0 + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -2537,9 +1850,7 @@ public void test1() throws Throwable { } value = msg.states[75].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[75].mesid.code + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.states[75].mesid.code + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -2547,9 +1858,7 @@ public void test1() throws Throwable { } value = msg.states[75].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[75].mesid.sat + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.states[75].mesid.sat + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -2557,9 +1866,7 @@ public void test1() throws Throwable { } value = msg.states[76].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[76].cn0 + "' != '" + 205 + "'", - value.equals(BigInteger.valueOf(205L))); + org.junit.Assert.assertTrue("'" + msg.states[76].cn0 + "' != '" + 205 + "'", value.equals(BigInteger.valueOf( 205L ) ) ); } else { value = value.longValue(); expected = 205L; @@ -2567,9 +1874,7 @@ public void test1() throws Throwable { } value = msg.states[76].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[76].mesid.code + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.states[76].mesid.code + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -2577,9 +1882,7 @@ public void test1() throws Throwable { } value = msg.states[76].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[76].mesid.sat + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.states[76].mesid.sat + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -2587,9 +1890,7 @@ public void test1() throws Throwable { } value = msg.states[77].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[77].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[77].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2597,9 +1898,7 @@ public void test1() throws Throwable { } value = msg.states[77].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[77].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[77].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2607,9 +1906,7 @@ public void test1() throws Throwable { } value = msg.states[77].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[77].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[77].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2617,9 +1914,7 @@ public void test1() throws Throwable { } value = msg.states[78].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[78].cn0 + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[78].cn0 + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2627,9 +1922,7 @@ public void test1() throws Throwable { } value = msg.states[78].mesid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[78].mesid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[78].mesid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2637,9 +1930,7 @@ public void test1() throws Throwable { } value = msg.states[78].mesid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[78].mesid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[78].mesid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; diff --git a/java/test/auto_check_sbp_tracking_MsgTrackingIqDepATest.java b/java/test/auto_check_sbp_tracking_MsgTrackingIqDepATest.java index 22647c3bf..a623d05eb 100644 --- a/java/test/auto_check_sbp_tracking_MsgTrackingIqDepATest.java +++ b/java/test/auto_check_sbp_tracking_MsgTrackingIqDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingIqDepA.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingIqDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.tracking.MsgTrackingIqDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_tracking_MsgTrackingIqDepATest { @@ -30,24 +34,15 @@ public class auto_check_sbp_tracking_MsgTrackingIqDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingIqDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 139, (byte) 28, (byte) 250, (byte) 15, (byte) 0, (byte) 99, (byte) 90, - (byte) 170, (byte) 96, (byte) 71, (byte) 121, (byte) 33, (byte) 161, (byte) 52, - (byte) 211, (byte) 162, (byte) 101, (byte) 41, (byte) 36, (byte) 226, (byte) 99, - (byte) 71, (byte) 75, (byte) 14, (byte) 240, (byte) 134, (byte) 82, (byte) 175, - (byte) 83, - }; - SBPMessage sbp = new SBPMessage(0x43b8, 0x1c, payload); - MsgTrackingIqDepA msg = new MsgTrackingIqDepA(sbp); + byte[] payload = new byte[] {(byte)139,(byte)28,(byte)250,(byte)15,(byte)0,(byte)99,(byte)90,(byte)170,(byte)96,(byte)71,(byte)121,(byte)33,(byte)161,(byte)52,(byte)211,(byte)162,(byte)101,(byte)41,(byte)36,(byte)226,(byte)99,(byte)71,(byte)75,(byte)14,(byte)240,(byte)134,(byte)82,(byte)175,(byte)83, }; + SBPMessage sbp = new SBPMessage( 0x43b8, 0x1c, payload ); + MsgTrackingIqDepA msg = new MsgTrackingIqDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.channel; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.channel + "' != '" + 139 + "'", - value.equals(BigInteger.valueOf(139L))); + org.junit.Assert.assertTrue("'" + msg.channel + "' != '" + 139 + "'", value.equals(BigInteger.valueOf( 139L ) ) ); } else { value = value.longValue(); expected = 139L; @@ -55,9 +50,7 @@ public void test1() throws Throwable { } value = msg.corrs[0].I; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[0].I + "' != '" + 1621776995 + "'", - value.equals(BigInteger.valueOf(1621776995L))); + org.junit.Assert.assertTrue("'" + msg.corrs[0].I + "' != '" + 1621776995 + "'", value.equals(BigInteger.valueOf( 1621776995L ) ) ); } else { value = value.longValue(); expected = 1621776995L; @@ -65,9 +58,7 @@ public void test1() throws Throwable { } value = msg.corrs[0].Q; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[0].Q + "' != '" + -1591641785 + "'", - value.equals(BigInteger.valueOf(-1591641785L))); + org.junit.Assert.assertTrue("'" + msg.corrs[0].Q + "' != '" + -1591641785 + "'", value.equals(BigInteger.valueOf( -1591641785L ) ) ); } else { value = value.longValue(); expected = -1591641785L; @@ -75,9 +66,7 @@ public void test1() throws Throwable { } value = msg.corrs[1].I; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[1].I + "' != '" + 1705169716 + "'", - value.equals(BigInteger.valueOf(1705169716L))); + org.junit.Assert.assertTrue("'" + msg.corrs[1].I + "' != '" + 1705169716 + "'", value.equals(BigInteger.valueOf( 1705169716L ) ) ); } else { value = value.longValue(); expected = 1705169716L; @@ -85,9 +74,7 @@ public void test1() throws Throwable { } value = msg.corrs[1].Q; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[1].Q + "' != '" + 1675764777 + "'", - value.equals(BigInteger.valueOf(1675764777L))); + org.junit.Assert.assertTrue("'" + msg.corrs[1].Q + "' != '" + 1675764777 + "'", value.equals(BigInteger.valueOf( 1675764777L ) ) ); } else { value = value.longValue(); expected = 1675764777L; @@ -95,9 +82,7 @@ public void test1() throws Throwable { } value = msg.corrs[2].I; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[2].I + "' != '" + -267498681 + "'", - value.equals(BigInteger.valueOf(-267498681L))); + org.junit.Assert.assertTrue("'" + msg.corrs[2].I + "' != '" + -267498681 + "'", value.equals(BigInteger.valueOf( -267498681L ) ) ); } else { value = value.longValue(); expected = -267498681L; @@ -105,9 +90,7 @@ public void test1() throws Throwable { } value = msg.corrs[2].Q; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[2].Q + "' != '" + 1403998854 + "'", - value.equals(BigInteger.valueOf(1403998854L))); + org.junit.Assert.assertTrue("'" + msg.corrs[2].Q + "' != '" + 1403998854 + "'", value.equals(BigInteger.valueOf( 1403998854L ) ) ); } else { value = value.longValue(); expected = 1403998854L; @@ -115,9 +98,7 @@ public void test1() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -125,9 +106,7 @@ public void test1() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -135,9 +114,7 @@ public void test1() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 64028 + "'", - value.equals(BigInteger.valueOf(64028L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 64028 + "'", value.equals(BigInteger.valueOf( 64028L ) ) ); } else { value = value.longValue(); expected = 64028L; diff --git a/java/test/auto_check_sbp_tracking_MsgTrackingIqDepBTest.java b/java/test/auto_check_sbp_tracking_MsgTrackingIqDepBTest.java index 38a0416df..bf172ca91 100644 --- a/java/test/auto_check_sbp_tracking_MsgTrackingIqDepBTest.java +++ b/java/test/auto_check_sbp_tracking_MsgTrackingIqDepBTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingIqDepB.yaml by generate.py. Do not modify -// by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingIqDepB.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.tracking.MsgTrackingIqDepB; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_tracking_MsgTrackingIqDepBTest { @@ -30,45 +34,15 @@ public class auto_check_sbp_tracking_MsgTrackingIqDepBTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingIqDepBTest.test1"); - byte[] payload = - new byte[] { - (byte) 45, - (byte) 188, - (byte) 183, - (byte) 72, - (byte) 185, - (byte) 157, - (byte) 15, - (byte) 187, - (byte) 249, - (byte) 101, - (byte) 24, - (byte) 135, - (byte) 146, - (byte) 180, - (byte) 224, - (byte) 123, - (byte) 235, - (byte) 142, - (byte) 208, - (byte) 102, - (byte) 112, - (byte) 25, - (byte) 21, - (byte) 177, - (byte) 96, - (byte) 116, - (byte) 68, - }; - SBPMessage sbp = new SBPMessage(0x6527, 0x2c, payload); - MsgTrackingIqDepB msg = new MsgTrackingIqDepB(sbp); + byte[] payload = new byte[] {(byte)45,(byte)188,(byte)183,(byte)72,(byte)185,(byte)157,(byte)15,(byte)187,(byte)249,(byte)101,(byte)24,(byte)135,(byte)146,(byte)180,(byte)224,(byte)123,(byte)235,(byte)142,(byte)208,(byte)102,(byte)112,(byte)25,(byte)21,(byte)177,(byte)96,(byte)116,(byte)68, }; + SBPMessage sbp = new SBPMessage( 0x6527, 0x2c, payload ); + MsgTrackingIqDepB msg = new MsgTrackingIqDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.channel; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.channel + "' != '" + 45 + "'", value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.channel + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -76,9 +50,7 @@ public void test1() throws Throwable { } value = msg.corrs[0].I; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[0].I + "' != '" + 261994824 + "'", - value.equals(BigInteger.valueOf(261994824L))); + org.junit.Assert.assertTrue("'" + msg.corrs[0].I + "' != '" + 261994824 + "'", value.equals(BigInteger.valueOf( 261994824L ) ) ); } else { value = value.longValue(); expected = 261994824L; @@ -86,9 +58,7 @@ public void test1() throws Throwable { } value = msg.corrs[0].Q; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[0].Q + "' != '" + 409336251 + "'", - value.equals(BigInteger.valueOf(409336251L))); + org.junit.Assert.assertTrue("'" + msg.corrs[0].Q + "' != '" + 409336251 + "'", value.equals(BigInteger.valueOf( 409336251L ) ) ); } else { value = value.longValue(); expected = 409336251L; @@ -96,9 +66,7 @@ public void test1() throws Throwable { } value = msg.corrs[1].I; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[1].I + "' != '" + -525036921 + "'", - value.equals(BigInteger.valueOf(-525036921L))); + org.junit.Assert.assertTrue("'" + msg.corrs[1].I + "' != '" + -525036921 + "'", value.equals(BigInteger.valueOf( -525036921L ) ) ); } else { value = value.longValue(); expected = -525036921L; @@ -106,9 +74,7 @@ public void test1() throws Throwable { } value = msg.corrs[1].Q; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[1].Q + "' != '" + -795939973 + "'", - value.equals(BigInteger.valueOf(-795939973L))); + org.junit.Assert.assertTrue("'" + msg.corrs[1].Q + "' != '" + -795939973 + "'", value.equals(BigInteger.valueOf( -795939973L ) ) ); } else { value = value.longValue(); expected = -795939973L; @@ -116,9 +82,7 @@ public void test1() throws Throwable { } value = msg.corrs[2].I; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[2].I + "' != '" + 353988710 + "'", - value.equals(BigInteger.valueOf(353988710L))); + org.junit.Assert.assertTrue("'" + msg.corrs[2].I + "' != '" + 353988710 + "'", value.equals(BigInteger.valueOf( 353988710L ) ) ); } else { value = value.longValue(); expected = 353988710L; @@ -126,9 +90,7 @@ public void test1() throws Throwable { } value = msg.corrs[2].Q; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[2].Q + "' != '" + 1148477617 + "'", - value.equals(BigInteger.valueOf(1148477617L))); + org.junit.Assert.assertTrue("'" + msg.corrs[2].Q + "' != '" + 1148477617 + "'", value.equals(BigInteger.valueOf( 1148477617L ) ) ); } else { value = value.longValue(); expected = 1148477617L; @@ -136,9 +98,7 @@ public void test1() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -146,9 +106,7 @@ public void test1() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 188 + "'", - value.equals(BigInteger.valueOf(188L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 188 + "'", value.equals(BigInteger.valueOf( 188L ) ) ); } else { value = value.longValue(); expected = 188L; diff --git a/java/test/auto_check_sbp_tracking_MsgTrackingIqTest.java b/java/test/auto_check_sbp_tracking_MsgTrackingIqTest.java index f187bacce..f6426ade3 100644 --- a/java/test/auto_check_sbp_tracking_MsgTrackingIqTest.java +++ b/java/test/auto_check_sbp_tracking_MsgTrackingIqTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingIq.yaml -// by generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingIq.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.tracking.MsgTrackingIq; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_tracking_MsgTrackingIqTest { @@ -27,35 +32,17 @@ public class auto_check_sbp_tracking_MsgTrackingIqTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingIqTest.test1"); - byte[] payload = - new byte[] { - (byte) 145, - (byte) 121, - (byte) 203, - (byte) 47, - (byte) 217, - (byte) 239, - (byte) 55, - (byte) 45, - (byte) 38, - (byte) 189, - (byte) 88, - (byte) 159, - (byte) 19, - (byte) 208, - (byte) 12, - }; - SBPMessage sbp = new SBPMessage(0x5002, 0x2d, payload); - MsgTrackingIq msg = new MsgTrackingIq(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingIqTest.test1"); + byte[] payload = new byte[] {(byte)145,(byte)121,(byte)203,(byte)47,(byte)217,(byte)239,(byte)55,(byte)45,(byte)38,(byte)189,(byte)88,(byte)159,(byte)19,(byte)208,(byte)12, }; + SBPMessage sbp = new SBPMessage( 0x5002, 0x2d, payload ); + MsgTrackingIq msg = new MsgTrackingIq( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.channel; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.channel + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.channel + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -63,9 +50,7 @@ public void test1() throws Throwable { } value = msg.corrs[0].I; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[0].I + "' != '" + -9937 + "'", - value.equals(BigInteger.valueOf(-9937L))); + org.junit.Assert.assertTrue("'" + msg.corrs[0].I + "' != '" + -9937 + "'", value.equals(BigInteger.valueOf( -9937L ) ) ); } else { value = value.longValue(); expected = -9937L; @@ -73,9 +58,7 @@ public void test1() throws Throwable { } value = msg.corrs[0].Q; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[0].Q + "' != '" + 14319 + "'", - value.equals(BigInteger.valueOf(14319L))); + org.junit.Assert.assertTrue("'" + msg.corrs[0].Q + "' != '" + 14319 + "'", value.equals(BigInteger.valueOf( 14319L ) ) ); } else { value = value.longValue(); expected = 14319L; @@ -83,9 +66,7 @@ public void test1() throws Throwable { } value = msg.corrs[1].I; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[1].I + "' != '" + 9773 + "'", - value.equals(BigInteger.valueOf(9773L))); + org.junit.Assert.assertTrue("'" + msg.corrs[1].I + "' != '" + 9773 + "'", value.equals(BigInteger.valueOf( 9773L ) ) ); } else { value = value.longValue(); expected = 9773L; @@ -93,9 +74,7 @@ public void test1() throws Throwable { } value = msg.corrs[1].Q; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[1].Q + "' != '" + 22717 + "'", - value.equals(BigInteger.valueOf(22717L))); + org.junit.Assert.assertTrue("'" + msg.corrs[1].Q + "' != '" + 22717 + "'", value.equals(BigInteger.valueOf( 22717L ) ) ); } else { value = value.longValue(); expected = 22717L; @@ -103,9 +82,7 @@ public void test1() throws Throwable { } value = msg.corrs[2].I; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[2].I + "' != '" + 5023 + "'", - value.equals(BigInteger.valueOf(5023L))); + org.junit.Assert.assertTrue("'" + msg.corrs[2].I + "' != '" + 5023 + "'", value.equals(BigInteger.valueOf( 5023L ) ) ); } else { value = value.longValue(); expected = 5023L; @@ -113,9 +90,7 @@ public void test1() throws Throwable { } value = msg.corrs[2].Q; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corrs[2].Q + "' != '" + 3280 + "'", - value.equals(BigInteger.valueOf(3280L))); + org.junit.Assert.assertTrue("'" + msg.corrs[2].Q + "' != '" + 3280 + "'", value.equals(BigInteger.valueOf( 3280L ) ) ); } else { value = value.longValue(); expected = 3280L; @@ -123,9 +98,7 @@ public void test1() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -133,9 +106,7 @@ public void test1() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; diff --git a/java/test/auto_check_sbp_tracking_MsgTrackingStateDepBTest.java b/java/test/auto_check_sbp_tracking_MsgTrackingStateDepBTest.java index 0e54fbe27..4d8e1da40 100644 --- a/java/test/auto_check_sbp_tracking_MsgTrackingStateDepBTest.java +++ b/java/test/auto_check_sbp_tracking_MsgTrackingStateDepBTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingStateDepB.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingStateDepB.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.tracking.MsgTrackingStateDepB; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_tracking_MsgTrackingStateDepBTest { @@ -30,272 +34,16 @@ public class auto_check_sbp_tracking_MsgTrackingStateDepBTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDepBTest.test1"); - byte[] payload = - new byte[] { - (byte) 115, - (byte) 183, - (byte) 227, - (byte) 63, - (byte) 68, - (byte) 154, - (byte) 1, - (byte) 183, - (byte) 69, - (byte) 255, - (byte) 175, - (byte) 121, - (byte) 43, - (byte) 222, - (byte) 51, - (byte) 67, - (byte) 35, - (byte) 69, - (byte) 78, - (byte) 240, - (byte) 5, - (byte) 53, - (byte) 20, - (byte) 51, - (byte) 211, - (byte) 54, - (byte) 69, - (byte) 153, - (byte) 130, - (byte) 237, - (byte) 66, - (byte) 155, - (byte) 51, - (byte) 227, - (byte) 71, - (byte) 69, - (byte) 53, - (byte) 242, - (byte) 136, - (byte) 161, - (byte) 190, - (byte) 205, - (byte) 188, - (byte) 6, - (byte) 70, - (byte) 153, - (byte) 125, - (byte) 255, - (byte) 142, - (byte) 149, - (byte) 154, - (byte) 217, - (byte) 184, - (byte) 69, - (byte) 248, - (byte) 102, - (byte) 95, - (byte) 31, - (byte) 76, - (byte) 154, - (byte) 33, - (byte) 169, - (byte) 69, - (byte) 131, - (byte) 115, - (byte) 141, - (byte) 27, - (byte) 12, - (byte) 154, - (byte) 225, - (byte) 200, - (byte) 69, - (byte) 208, - (byte) 44, - (byte) 147, - (byte) 39, - (byte) 23, - (byte) 51, - (byte) 3, - (byte) 66, - (byte) 69, - (byte) 237, - (byte) 159, - (byte) 251, - (byte) 49, - (byte) 203, - (byte) 51, - (byte) 99, - (byte) 102, - (byte) 69, - (byte) 70, - (byte) 214, - (byte) 87, - (byte) 128, - (byte) 206, - (byte) 154, - (byte) 121, - (byte) 186, - (byte) 69, - (byte) 14, - (byte) 206, - (byte) 111, - (byte) 218, - (byte) 19, - (byte) 154, - (byte) 121, - (byte) 169, - (byte) 69, - (byte) 216, - (byte) 98, - (byte) 209, - (byte) 54, - (byte) 2, - (byte) 154, - (byte) 25, - (byte) 219, - (byte) 67, - (byte) 200, - (byte) 133, - (byte) 99, - (byte) 7, - (byte) 34, - (byte) 102, - (byte) 198, - (byte) 232, - (byte) 68, - (byte) 155, - (byte) 43, - (byte) 85, - (byte) 135, - (byte) 46, - (byte) 154, - (byte) 177, - (byte) 170, - (byte) 69, - (byte) 155, - (byte) 3, - (byte) 83, - (byte) 171, - (byte) 201, - (byte) 154, - (byte) 241, - (byte) 232, - (byte) 69, - (byte) 121, - (byte) 43, - (byte) 197, - (byte) 16, - (byte) 19, - (byte) 154, - (byte) 241, - (byte) 222, - (byte) 69, - (byte) 128, - (byte) 245, - (byte) 53, - (byte) 63, - (byte) 176, - (byte) 51, - (byte) 115, - (byte) 66, - (byte) 69, - (byte) 36, - (byte) 20, - (byte) 61, - (byte) 153, - (byte) 51, - (byte) 154, - (byte) 73, - (byte) 134, - (byte) 69, - (byte) 46, - (byte) 82, - (byte) 116, - (byte) 140, - (byte) 22, - (byte) 51, - (byte) 147, - (byte) 37, - (byte) 69, - (byte) 177, - (byte) 67, - (byte) 146, - (byte) 96, - (byte) 143, - (byte) 205, - (byte) 76, - (byte) 107, - (byte) 68, - (byte) 220, - (byte) 51, - (byte) 160, - (byte) 201, - (byte) 251, - (byte) 102, - (byte) 102, - (byte) 192, - (byte) 68, - (byte) 168, - (byte) 194, - (byte) 2, - (byte) 161, - (byte) 220, - (byte) 102, - (byte) 102, - (byte) 180, - (byte) 68, - (byte) 69, - (byte) 8, - (byte) 9, - (byte) 125, - (byte) 178, - (byte) 102, - (byte) 70, - (byte) 134, - (byte) 68, - (byte) 185, - (byte) 20, - (byte) 135, - (byte) 186, - (byte) 171, - (byte) 51, - (byte) 163, - (byte) 4, - (byte) 69, - (byte) 18, - (byte) 124, - (byte) 155, - (byte) 85, - (byte) 170, - (byte) 205, - (byte) 208, - (byte) 13, - (byte) 70, - (byte) 57, - (byte) 244, - (byte) 206, - (byte) 255, - (byte) 186, - (byte) 154, - (byte) 105, - (byte) 149, - (byte) 69, - (byte) 165, - (byte) 199, - (byte) 93, - (byte) 181, - (byte) 175, - (byte) 51, - (byte) 67, - (byte) 64, - (byte) 69, - }; - SBPMessage sbp = new SBPMessage(0xf1f2, 0x13, payload); - MsgTrackingStateDepB msg = new MsgTrackingStateDepB(sbp); + byte[] payload = new byte[] {(byte)115,(byte)183,(byte)227,(byte)63,(byte)68,(byte)154,(byte)1,(byte)183,(byte)69,(byte)255,(byte)175,(byte)121,(byte)43,(byte)222,(byte)51,(byte)67,(byte)35,(byte)69,(byte)78,(byte)240,(byte)5,(byte)53,(byte)20,(byte)51,(byte)211,(byte)54,(byte)69,(byte)153,(byte)130,(byte)237,(byte)66,(byte)155,(byte)51,(byte)227,(byte)71,(byte)69,(byte)53,(byte)242,(byte)136,(byte)161,(byte)190,(byte)205,(byte)188,(byte)6,(byte)70,(byte)153,(byte)125,(byte)255,(byte)142,(byte)149,(byte)154,(byte)217,(byte)184,(byte)69,(byte)248,(byte)102,(byte)95,(byte)31,(byte)76,(byte)154,(byte)33,(byte)169,(byte)69,(byte)131,(byte)115,(byte)141,(byte)27,(byte)12,(byte)154,(byte)225,(byte)200,(byte)69,(byte)208,(byte)44,(byte)147,(byte)39,(byte)23,(byte)51,(byte)3,(byte)66,(byte)69,(byte)237,(byte)159,(byte)251,(byte)49,(byte)203,(byte)51,(byte)99,(byte)102,(byte)69,(byte)70,(byte)214,(byte)87,(byte)128,(byte)206,(byte)154,(byte)121,(byte)186,(byte)69,(byte)14,(byte)206,(byte)111,(byte)218,(byte)19,(byte)154,(byte)121,(byte)169,(byte)69,(byte)216,(byte)98,(byte)209,(byte)54,(byte)2,(byte)154,(byte)25,(byte)219,(byte)67,(byte)200,(byte)133,(byte)99,(byte)7,(byte)34,(byte)102,(byte)198,(byte)232,(byte)68,(byte)155,(byte)43,(byte)85,(byte)135,(byte)46,(byte)154,(byte)177,(byte)170,(byte)69,(byte)155,(byte)3,(byte)83,(byte)171,(byte)201,(byte)154,(byte)241,(byte)232,(byte)69,(byte)121,(byte)43,(byte)197,(byte)16,(byte)19,(byte)154,(byte)241,(byte)222,(byte)69,(byte)128,(byte)245,(byte)53,(byte)63,(byte)176,(byte)51,(byte)115,(byte)66,(byte)69,(byte)36,(byte)20,(byte)61,(byte)153,(byte)51,(byte)154,(byte)73,(byte)134,(byte)69,(byte)46,(byte)82,(byte)116,(byte)140,(byte)22,(byte)51,(byte)147,(byte)37,(byte)69,(byte)177,(byte)67,(byte)146,(byte)96,(byte)143,(byte)205,(byte)76,(byte)107,(byte)68,(byte)220,(byte)51,(byte)160,(byte)201,(byte)251,(byte)102,(byte)102,(byte)192,(byte)68,(byte)168,(byte)194,(byte)2,(byte)161,(byte)220,(byte)102,(byte)102,(byte)180,(byte)68,(byte)69,(byte)8,(byte)9,(byte)125,(byte)178,(byte)102,(byte)70,(byte)134,(byte)68,(byte)185,(byte)20,(byte)135,(byte)186,(byte)171,(byte)51,(byte)163,(byte)4,(byte)69,(byte)18,(byte)124,(byte)155,(byte)85,(byte)170,(byte)205,(byte)208,(byte)13,(byte)70,(byte)57,(byte)244,(byte)206,(byte)255,(byte)186,(byte)154,(byte)105,(byte)149,(byte)69,(byte)165,(byte)199,(byte)93,(byte)181,(byte)175,(byte)51,(byte)67,(byte)64,(byte)69, }; + SBPMessage sbp = new SBPMessage( 0xf1f2, 0x13, payload ); + MsgTrackingStateDepB msg = new MsgTrackingStateDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.states[0].cn0, 5.85620019531250000e+03, DELTA); value = msg.states[0].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.code + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.code + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -303,9 +51,7 @@ public void test1() throws Throwable { } value = msg.states[0].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.reserved + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.reserved + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -313,9 +59,7 @@ public void test1() throws Throwable { } value = msg.states[0].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.sat + "' != '" + 58295 + "'", - value.equals(BigInteger.valueOf(58295L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.sat + "' != '" + 58295 + "'", value.equals(BigInteger.valueOf( 58295L ) ) ); } else { value = value.longValue(); expected = 58295L; @@ -323,9 +67,7 @@ public void test1() throws Throwable { } value = msg.states[0].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].state + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.states[0].state + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -334,9 +76,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[1].cn0, 2.61219995117187500e+03, DELTA); value = msg.states[1].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.code + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.code + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -344,9 +84,7 @@ public void test1() throws Throwable { } value = msg.states[1].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.reserved + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.reserved + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -354,9 +92,7 @@ public void test1() throws Throwable { } value = msg.states[1].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.sat + "' != '" + 31151 + "'", - value.equals(BigInteger.valueOf(31151L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.sat + "' != '" + 31151 + "'", value.equals(BigInteger.valueOf( 31151L ) ) ); } else { value = value.longValue(); expected = 31151L; @@ -364,9 +100,7 @@ public void test1() throws Throwable { } value = msg.states[1].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].state + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.states[1].state + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -375,9 +109,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[2].cn0, 2.92519995117187500e+03, DELTA); value = msg.states[2].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.code + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.code + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -385,9 +117,7 @@ public void test1() throws Throwable { } value = msg.states[2].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.reserved + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.reserved + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -395,9 +125,7 @@ public void test1() throws Throwable { } value = msg.states[2].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.sat + "' != '" + 1520 + "'", - value.equals(BigInteger.valueOf(1520L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.sat + "' != '" + 1520 + "'", value.equals(BigInteger.valueOf( 1520L ) ) ); } else { value = value.longValue(); expected = 1520L; @@ -405,9 +133,7 @@ public void test1() throws Throwable { } value = msg.states[2].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].state + "' != '" + 78 + "'", - value.equals(BigInteger.valueOf(78L))); + org.junit.Assert.assertTrue("'" + msg.states[2].state + "' != '" + 78 + "'", value.equals(BigInteger.valueOf( 78L ) ) ); } else { value = value.longValue(); expected = 78L; @@ -416,9 +142,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[3].cn0, 3.19819995117187500e+03, DELTA); value = msg.states[3].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.code + "' != '" + 66 + "'", - value.equals(BigInteger.valueOf(66L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.code + "' != '" + 66 + "'", value.equals(BigInteger.valueOf( 66L ) ) ); } else { value = value.longValue(); expected = 66L; @@ -426,9 +150,7 @@ public void test1() throws Throwable { } value = msg.states[3].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.reserved + "' != '" + 155 + "'", - value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.reserved + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -436,9 +158,7 @@ public void test1() throws Throwable { } value = msg.states[3].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.sat + "' != '" + 60802 + "'", - value.equals(BigInteger.valueOf(60802L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.sat + "' != '" + 60802 + "'", value.equals(BigInteger.valueOf( 60802L ) ) ); } else { value = value.longValue(); expected = 60802L; @@ -446,9 +166,7 @@ public void test1() throws Throwable { } value = msg.states[3].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].state + "' != '" + 153 + "'", - value.equals(BigInteger.valueOf(153L))); + org.junit.Assert.assertTrue("'" + msg.states[3].state + "' != '" + 153 + "'", value.equals(BigInteger.valueOf( 153L ) ) ); } else { value = value.longValue(); expected = 153L; @@ -457,9 +175,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[4].cn0, 8.62320019531250000e+03, DELTA); value = msg.states[4].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.code + "' != '" + 161 + "'", - value.equals(BigInteger.valueOf(161L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.code + "' != '" + 161 + "'", value.equals(BigInteger.valueOf( 161L ) ) ); } else { value = value.longValue(); expected = 161L; @@ -467,9 +183,7 @@ public void test1() throws Throwable { } value = msg.states[4].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.reserved + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.reserved + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -477,9 +191,7 @@ public void test1() throws Throwable { } value = msg.states[4].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.sat + "' != '" + 35058 + "'", - value.equals(BigInteger.valueOf(35058L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.sat + "' != '" + 35058 + "'", value.equals(BigInteger.valueOf( 35058L ) ) ); } else { value = value.longValue(); expected = 35058L; @@ -487,9 +199,7 @@ public void test1() throws Throwable { } value = msg.states[4].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].state + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.states[4].state + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -498,9 +208,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[5].cn0, 5.91520019531250000e+03, DELTA); value = msg.states[5].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.code + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.code + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -508,9 +216,7 @@ public void test1() throws Throwable { } value = msg.states[5].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.reserved + "' != '" + 149 + "'", - value.equals(BigInteger.valueOf(149L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.reserved + "' != '" + 149 + "'", value.equals(BigInteger.valueOf( 149L ) ) ); } else { value = value.longValue(); expected = 149L; @@ -518,9 +224,7 @@ public void test1() throws Throwable { } value = msg.states[5].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.sat + "' != '" + 65405 + "'", - value.equals(BigInteger.valueOf(65405L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.sat + "' != '" + 65405 + "'", value.equals(BigInteger.valueOf( 65405L ) ) ); } else { value = value.longValue(); expected = 65405L; @@ -528,9 +232,7 @@ public void test1() throws Throwable { } value = msg.states[5].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].state + "' != '" + 153 + "'", - value.equals(BigInteger.valueOf(153L))); + org.junit.Assert.assertTrue("'" + msg.states[5].state + "' != '" + 153 + "'", value.equals(BigInteger.valueOf( 153L ) ) ); } else { value = value.longValue(); expected = 153L; @@ -539,9 +241,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[6].cn0, 5.41220019531250000e+03, DELTA); value = msg.states[6].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.code + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.code + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -549,9 +249,7 @@ public void test1() throws Throwable { } value = msg.states[6].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.reserved + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.reserved + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -559,9 +257,7 @@ public void test1() throws Throwable { } value = msg.states[6].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.sat + "' != '" + 24422 + "'", - value.equals(BigInteger.valueOf(24422L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.sat + "' != '" + 24422 + "'", value.equals(BigInteger.valueOf( 24422L ) ) ); } else { value = value.longValue(); expected = 24422L; @@ -569,9 +265,7 @@ public void test1() throws Throwable { } value = msg.states[6].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].state + "' != '" + 248 + "'", - value.equals(BigInteger.valueOf(248L))); + org.junit.Assert.assertTrue("'" + msg.states[6].state + "' != '" + 248 + "'", value.equals(BigInteger.valueOf( 248L ) ) ); } else { value = value.longValue(); expected = 248L; @@ -580,9 +274,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[7].cn0, 6.42820019531250000e+03, DELTA); value = msg.states[7].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.code + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.code + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -590,9 +282,7 @@ public void test1() throws Throwable { } value = msg.states[7].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.reserved + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.reserved + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -600,9 +290,7 @@ public void test1() throws Throwable { } value = msg.states[7].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.sat + "' != '" + 36211 + "'", - value.equals(BigInteger.valueOf(36211L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.sat + "' != '" + 36211 + "'", value.equals(BigInteger.valueOf( 36211L ) ) ); } else { value = value.longValue(); expected = 36211L; @@ -610,9 +298,7 @@ public void test1() throws Throwable { } value = msg.states[7].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].state + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.states[7].state + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -621,9 +307,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[8].cn0, 3.10419995117187500e+03, DELTA); value = msg.states[8].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.code + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.code + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -631,9 +315,7 @@ public void test1() throws Throwable { } value = msg.states[8].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.reserved + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.reserved + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -641,9 +323,7 @@ public void test1() throws Throwable { } value = msg.states[8].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.sat + "' != '" + 37676 + "'", - value.equals(BigInteger.valueOf(37676L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.sat + "' != '" + 37676 + "'", value.equals(BigInteger.valueOf( 37676L ) ) ); } else { value = value.longValue(); expected = 37676L; @@ -651,9 +331,7 @@ public void test1() throws Throwable { } value = msg.states[8].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].state + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.states[8].state + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -662,9 +340,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[9].cn0, 3.68619995117187500e+03, DELTA); value = msg.states[9].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.code + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.code + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -672,9 +348,7 @@ public void test1() throws Throwable { } value = msg.states[9].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.reserved + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.reserved + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -682,9 +356,7 @@ public void test1() throws Throwable { } value = msg.states[9].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.sat + "' != '" + 64415 + "'", - value.equals(BigInteger.valueOf(64415L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.sat + "' != '" + 64415 + "'", value.equals(BigInteger.valueOf( 64415L ) ) ); } else { value = value.longValue(); expected = 64415L; @@ -692,9 +364,7 @@ public void test1() throws Throwable { } value = msg.states[9].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].state + "' != '" + 237 + "'", - value.equals(BigInteger.valueOf(237L))); + org.junit.Assert.assertTrue("'" + msg.states[9].state + "' != '" + 237 + "'", value.equals(BigInteger.valueOf( 237L ) ) ); } else { value = value.longValue(); expected = 237L; @@ -703,9 +373,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[10].cn0, 5.96720019531250000e+03, DELTA); value = msg.states[10].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.code + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.code + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -713,9 +381,7 @@ public void test1() throws Throwable { } value = msg.states[10].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.reserved + "' != '" + 206 + "'", - value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.reserved + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; @@ -723,9 +389,7 @@ public void test1() throws Throwable { } value = msg.states[10].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.sat + "' != '" + 22486 + "'", - value.equals(BigInteger.valueOf(22486L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.sat + "' != '" + 22486 + "'", value.equals(BigInteger.valueOf( 22486L ) ) ); } else { value = value.longValue(); expected = 22486L; @@ -733,9 +397,7 @@ public void test1() throws Throwable { } value = msg.states[10].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].state + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.states[10].state + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -744,9 +406,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[11].cn0, 5.42320019531250000e+03, DELTA); value = msg.states[11].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[11].sid.code + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.states[11].sid.code + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -754,9 +414,7 @@ public void test1() throws Throwable { } value = msg.states[11].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[11].sid.reserved + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.states[11].sid.reserved + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -764,9 +422,7 @@ public void test1() throws Throwable { } value = msg.states[11].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[11].sid.sat + "' != '" + 28622 + "'", - value.equals(BigInteger.valueOf(28622L))); + org.junit.Assert.assertTrue("'" + msg.states[11].sid.sat + "' != '" + 28622 + "'", value.equals(BigInteger.valueOf( 28622L ) ) ); } else { value = value.longValue(); expected = 28622L; @@ -774,9 +430,7 @@ public void test1() throws Throwable { } value = msg.states[11].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[11].state + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.states[11].state + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -785,9 +439,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[12].cn0, 4.38200012207031250e+02, DELTA); value = msg.states[12].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[12].sid.code + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.states[12].sid.code + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -795,9 +447,7 @@ public void test1() throws Throwable { } value = msg.states[12].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[12].sid.reserved + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.states[12].sid.reserved + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -805,9 +455,7 @@ public void test1() throws Throwable { } value = msg.states[12].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[12].sid.sat + "' != '" + 53602 + "'", - value.equals(BigInteger.valueOf(53602L))); + org.junit.Assert.assertTrue("'" + msg.states[12].sid.sat + "' != '" + 53602 + "'", value.equals(BigInteger.valueOf( 53602L ) ) ); } else { value = value.longValue(); expected = 53602L; @@ -815,9 +463,7 @@ public void test1() throws Throwable { } value = msg.states[12].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[12].state + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.states[12].state + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -826,9 +472,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[13].cn0, 1.86219995117187500e+03, DELTA); value = msg.states[13].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[13].sid.code + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.states[13].sid.code + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -836,9 +480,7 @@ public void test1() throws Throwable { } value = msg.states[13].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[13].sid.reserved + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.states[13].sid.reserved + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -846,9 +488,7 @@ public void test1() throws Throwable { } value = msg.states[13].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[13].sid.sat + "' != '" + 25477 + "'", - value.equals(BigInteger.valueOf(25477L))); + org.junit.Assert.assertTrue("'" + msg.states[13].sid.sat + "' != '" + 25477 + "'", value.equals(BigInteger.valueOf( 25477L ) ) ); } else { value = value.longValue(); expected = 25477L; @@ -856,9 +496,7 @@ public void test1() throws Throwable { } value = msg.states[13].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[13].state + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.states[13].state + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -867,9 +505,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[14].cn0, 5.46220019531250000e+03, DELTA); value = msg.states[14].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[14].sid.code + "' != '" + 135 + "'", - value.equals(BigInteger.valueOf(135L))); + org.junit.Assert.assertTrue("'" + msg.states[14].sid.code + "' != '" + 135 + "'", value.equals(BigInteger.valueOf( 135L ) ) ); } else { value = value.longValue(); expected = 135L; @@ -877,9 +513,7 @@ public void test1() throws Throwable { } value = msg.states[14].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[14].sid.reserved + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.states[14].sid.reserved + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -887,9 +521,7 @@ public void test1() throws Throwable { } value = msg.states[14].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[14].sid.sat + "' != '" + 21803 + "'", - value.equals(BigInteger.valueOf(21803L))); + org.junit.Assert.assertTrue("'" + msg.states[14].sid.sat + "' != '" + 21803 + "'", value.equals(BigInteger.valueOf( 21803L ) ) ); } else { value = value.longValue(); expected = 21803L; @@ -897,9 +529,7 @@ public void test1() throws Throwable { } value = msg.states[14].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[14].state + "' != '" + 155 + "'", - value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.states[14].state + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -908,9 +538,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[15].cn0, 7.45420019531250000e+03, DELTA); value = msg.states[15].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[15].sid.code + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.states[15].sid.code + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -918,9 +546,7 @@ public void test1() throws Throwable { } value = msg.states[15].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[15].sid.reserved + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.states[15].sid.reserved + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -928,9 +554,7 @@ public void test1() throws Throwable { } value = msg.states[15].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[15].sid.sat + "' != '" + 21251 + "'", - value.equals(BigInteger.valueOf(21251L))); + org.junit.Assert.assertTrue("'" + msg.states[15].sid.sat + "' != '" + 21251 + "'", value.equals(BigInteger.valueOf( 21251L ) ) ); } else { value = value.longValue(); expected = 21251L; @@ -938,9 +562,7 @@ public void test1() throws Throwable { } value = msg.states[15].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[15].state + "' != '" + 155 + "'", - value.equals(BigInteger.valueOf(155L))); + org.junit.Assert.assertTrue("'" + msg.states[15].state + "' != '" + 155 + "'", value.equals(BigInteger.valueOf( 155L ) ) ); } else { value = value.longValue(); expected = 155L; @@ -949,9 +571,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[16].cn0, 7.13420019531250000e+03, DELTA); value = msg.states[16].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[16].sid.code + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.states[16].sid.code + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -959,9 +579,7 @@ public void test1() throws Throwable { } value = msg.states[16].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[16].sid.reserved + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.states[16].sid.reserved + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -969,9 +587,7 @@ public void test1() throws Throwable { } value = msg.states[16].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[16].sid.sat + "' != '" + 50475 + "'", - value.equals(BigInteger.valueOf(50475L))); + org.junit.Assert.assertTrue("'" + msg.states[16].sid.sat + "' != '" + 50475 + "'", value.equals(BigInteger.valueOf( 50475L ) ) ); } else { value = value.longValue(); expected = 50475L; @@ -979,9 +595,7 @@ public void test1() throws Throwable { } value = msg.states[16].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[16].state + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.states[16].state + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -990,9 +604,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[17].cn0, 3.11119995117187500e+03, DELTA); value = msg.states[17].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[17].sid.code + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.states[17].sid.code + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -1000,9 +612,7 @@ public void test1() throws Throwable { } value = msg.states[17].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[17].sid.reserved + "' != '" + 176 + "'", - value.equals(BigInteger.valueOf(176L))); + org.junit.Assert.assertTrue("'" + msg.states[17].sid.reserved + "' != '" + 176 + "'", value.equals(BigInteger.valueOf( 176L ) ) ); } else { value = value.longValue(); expected = 176L; @@ -1010,9 +620,7 @@ public void test1() throws Throwable { } value = msg.states[17].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[17].sid.sat + "' != '" + 13813 + "'", - value.equals(BigInteger.valueOf(13813L))); + org.junit.Assert.assertTrue("'" + msg.states[17].sid.sat + "' != '" + 13813 + "'", value.equals(BigInteger.valueOf( 13813L ) ) ); } else { value = value.longValue(); expected = 13813L; @@ -1020,9 +628,7 @@ public void test1() throws Throwable { } value = msg.states[17].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[17].state + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.states[17].state + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -1031,9 +637,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[18].cn0, 4.29720019531250000e+03, DELTA); value = msg.states[18].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[18].sid.code + "' != '" + 153 + "'", - value.equals(BigInteger.valueOf(153L))); + org.junit.Assert.assertTrue("'" + msg.states[18].sid.code + "' != '" + 153 + "'", value.equals(BigInteger.valueOf( 153L ) ) ); } else { value = value.longValue(); expected = 153L; @@ -1041,9 +645,7 @@ public void test1() throws Throwable { } value = msg.states[18].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[18].sid.reserved + "' != '" + 51 + "'", - value.equals(BigInteger.valueOf(51L))); + org.junit.Assert.assertTrue("'" + msg.states[18].sid.reserved + "' != '" + 51 + "'", value.equals(BigInteger.valueOf( 51L ) ) ); } else { value = value.longValue(); expected = 51L; @@ -1051,9 +653,7 @@ public void test1() throws Throwable { } value = msg.states[18].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[18].sid.sat + "' != '" + 15636 + "'", - value.equals(BigInteger.valueOf(15636L))); + org.junit.Assert.assertTrue("'" + msg.states[18].sid.sat + "' != '" + 15636 + "'", value.equals(BigInteger.valueOf( 15636L ) ) ); } else { value = value.longValue(); expected = 15636L; @@ -1061,9 +661,7 @@ public void test1() throws Throwable { } value = msg.states[18].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[18].state + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.states[18].state + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -1072,9 +670,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[19].cn0, 2.64919995117187500e+03, DELTA); value = msg.states[19].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[19].sid.code + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.states[19].sid.code + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -1082,9 +678,7 @@ public void test1() throws Throwable { } value = msg.states[19].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[19].sid.reserved + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.states[19].sid.reserved + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -1092,9 +686,7 @@ public void test1() throws Throwable { } value = msg.states[19].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[19].sid.sat + "' != '" + 29778 + "'", - value.equals(BigInteger.valueOf(29778L))); + org.junit.Assert.assertTrue("'" + msg.states[19].sid.sat + "' != '" + 29778 + "'", value.equals(BigInteger.valueOf( 29778L ) ) ); } else { value = value.longValue(); expected = 29778L; @@ -1102,9 +694,7 @@ public void test1() throws Throwable { } value = msg.states[19].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[19].state + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.states[19].state + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -1113,9 +703,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[20].cn0, 9.41200012207031250e+02, DELTA); value = msg.states[20].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[20].sid.code + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.states[20].sid.code + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -1123,9 +711,7 @@ public void test1() throws Throwable { } value = msg.states[20].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[20].sid.reserved + "' != '" + 143 + "'", - value.equals(BigInteger.valueOf(143L))); + org.junit.Assert.assertTrue("'" + msg.states[20].sid.reserved + "' != '" + 143 + "'", value.equals(BigInteger.valueOf( 143L ) ) ); } else { value = value.longValue(); expected = 143L; @@ -1133,9 +719,7 @@ public void test1() throws Throwable { } value = msg.states[20].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[20].sid.sat + "' != '" + 37443 + "'", - value.equals(BigInteger.valueOf(37443L))); + org.junit.Assert.assertTrue("'" + msg.states[20].sid.sat + "' != '" + 37443 + "'", value.equals(BigInteger.valueOf( 37443L ) ) ); } else { value = value.longValue(); expected = 37443L; @@ -1143,9 +727,7 @@ public void test1() throws Throwable { } value = msg.states[20].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[20].state + "' != '" + 177 + "'", - value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.states[20].state + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -1154,9 +736,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[21].cn0, 1.53919995117187500e+03, DELTA); value = msg.states[21].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[21].sid.code + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.states[21].sid.code + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -1164,9 +744,7 @@ public void test1() throws Throwable { } value = msg.states[21].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[21].sid.reserved + "' != '" + 251 + "'", - value.equals(BigInteger.valueOf(251L))); + org.junit.Assert.assertTrue("'" + msg.states[21].sid.reserved + "' != '" + 251 + "'", value.equals(BigInteger.valueOf( 251L ) ) ); } else { value = value.longValue(); expected = 251L; @@ -1174,9 +752,7 @@ public void test1() throws Throwable { } value = msg.states[21].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[21].sid.sat + "' != '" + 41011 + "'", - value.equals(BigInteger.valueOf(41011L))); + org.junit.Assert.assertTrue("'" + msg.states[21].sid.sat + "' != '" + 41011 + "'", value.equals(BigInteger.valueOf( 41011L ) ) ); } else { value = value.longValue(); expected = 41011L; @@ -1184,9 +760,7 @@ public void test1() throws Throwable { } value = msg.states[21].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[21].state + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.states[21].state + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -1195,9 +769,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[22].cn0, 1.44319995117187500e+03, DELTA); value = msg.states[22].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[22].sid.code + "' != '" + 161 + "'", - value.equals(BigInteger.valueOf(161L))); + org.junit.Assert.assertTrue("'" + msg.states[22].sid.code + "' != '" + 161 + "'", value.equals(BigInteger.valueOf( 161L ) ) ); } else { value = value.longValue(); expected = 161L; @@ -1205,9 +777,7 @@ public void test1() throws Throwable { } value = msg.states[22].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[22].sid.reserved + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.states[22].sid.reserved + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -1215,9 +785,7 @@ public void test1() throws Throwable { } value = msg.states[22].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[22].sid.sat + "' != '" + 706 + "'", - value.equals(BigInteger.valueOf(706L))); + org.junit.Assert.assertTrue("'" + msg.states[22].sid.sat + "' != '" + 706 + "'", value.equals(BigInteger.valueOf( 706L ) ) ); } else { value = value.longValue(); expected = 706L; @@ -1225,9 +793,7 @@ public void test1() throws Throwable { } value = msg.states[22].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[22].state + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.states[22].state + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -1236,9 +802,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[23].cn0, 1.07419995117187500e+03, DELTA); value = msg.states[23].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[23].sid.code + "' != '" + 125 + "'", - value.equals(BigInteger.valueOf(125L))); + org.junit.Assert.assertTrue("'" + msg.states[23].sid.code + "' != '" + 125 + "'", value.equals(BigInteger.valueOf( 125L ) ) ); } else { value = value.longValue(); expected = 125L; @@ -1246,9 +810,7 @@ public void test1() throws Throwable { } value = msg.states[23].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[23].sid.reserved + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.states[23].sid.reserved + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -1256,9 +818,7 @@ public void test1() throws Throwable { } value = msg.states[23].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[23].sid.sat + "' != '" + 2312 + "'", - value.equals(BigInteger.valueOf(2312L))); + org.junit.Assert.assertTrue("'" + msg.states[23].sid.sat + "' != '" + 2312 + "'", value.equals(BigInteger.valueOf( 2312L ) ) ); } else { value = value.longValue(); expected = 2312L; @@ -1266,9 +826,7 @@ public void test1() throws Throwable { } value = msg.states[23].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[23].state + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.states[23].state + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -1277,9 +835,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[24].cn0, 2.12219995117187500e+03, DELTA); value = msg.states[24].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[24].sid.code + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.states[24].sid.code + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -1287,9 +843,7 @@ public void test1() throws Throwable { } value = msg.states[24].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[24].sid.reserved + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.states[24].sid.reserved + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -1297,9 +851,7 @@ public void test1() throws Throwable { } value = msg.states[24].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[24].sid.sat + "' != '" + 34580 + "'", - value.equals(BigInteger.valueOf(34580L))); + org.junit.Assert.assertTrue("'" + msg.states[24].sid.sat + "' != '" + 34580 + "'", value.equals(BigInteger.valueOf( 34580L ) ) ); } else { value = value.longValue(); expected = 34580L; @@ -1307,9 +859,7 @@ public void test1() throws Throwable { } value = msg.states[24].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[24].state + "' != '" + 185 + "'", - value.equals(BigInteger.valueOf(185L))); + org.junit.Assert.assertTrue("'" + msg.states[24].state + "' != '" + 185 + "'", value.equals(BigInteger.valueOf( 185L ) ) ); } else { value = value.longValue(); expected = 185L; @@ -1318,9 +868,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[25].cn0, 9.07620019531250000e+03, DELTA); value = msg.states[25].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[25].sid.code + "' != '" + 85 + "'", - value.equals(BigInteger.valueOf(85L))); + org.junit.Assert.assertTrue("'" + msg.states[25].sid.code + "' != '" + 85 + "'", value.equals(BigInteger.valueOf( 85L ) ) ); } else { value = value.longValue(); expected = 85L; @@ -1328,9 +876,7 @@ public void test1() throws Throwable { } value = msg.states[25].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[25].sid.reserved + "' != '" + 170 + "'", - value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.states[25].sid.reserved + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -1338,9 +884,7 @@ public void test1() throws Throwable { } value = msg.states[25].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[25].sid.sat + "' != '" + 39804 + "'", - value.equals(BigInteger.valueOf(39804L))); + org.junit.Assert.assertTrue("'" + msg.states[25].sid.sat + "' != '" + 39804 + "'", value.equals(BigInteger.valueOf( 39804L ) ) ); } else { value = value.longValue(); expected = 39804L; @@ -1348,9 +892,7 @@ public void test1() throws Throwable { } value = msg.states[25].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[25].state + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.states[25].state + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -1359,9 +901,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[26].cn0, 4.78120019531250000e+03, DELTA); value = msg.states[26].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[26].sid.code + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.states[26].sid.code + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -1369,9 +909,7 @@ public void test1() throws Throwable { } value = msg.states[26].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[26].sid.reserved + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.states[26].sid.reserved + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -1379,9 +917,7 @@ public void test1() throws Throwable { } value = msg.states[26].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[26].sid.sat + "' != '" + 52980 + "'", - value.equals(BigInteger.valueOf(52980L))); + org.junit.Assert.assertTrue("'" + msg.states[26].sid.sat + "' != '" + 52980 + "'", value.equals(BigInteger.valueOf( 52980L ) ) ); } else { value = value.longValue(); expected = 52980L; @@ -1389,9 +925,7 @@ public void test1() throws Throwable { } value = msg.states[26].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[26].state + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.states[26].state + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -1400,9 +934,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[27].cn0, 3.07619995117187500e+03, DELTA); value = msg.states[27].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[27].sid.code + "' != '" + 181 + "'", - value.equals(BigInteger.valueOf(181L))); + org.junit.Assert.assertTrue("'" + msg.states[27].sid.code + "' != '" + 181 + "'", value.equals(BigInteger.valueOf( 181L ) ) ); } else { value = value.longValue(); expected = 181L; @@ -1410,9 +942,7 @@ public void test1() throws Throwable { } value = msg.states[27].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[27].sid.reserved + "' != '" + 175 + "'", - value.equals(BigInteger.valueOf(175L))); + org.junit.Assert.assertTrue("'" + msg.states[27].sid.reserved + "' != '" + 175 + "'", value.equals(BigInteger.valueOf( 175L ) ) ); } else { value = value.longValue(); expected = 175L; @@ -1420,9 +950,7 @@ public void test1() throws Throwable { } value = msg.states[27].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[27].sid.sat + "' != '" + 24007 + "'", - value.equals(BigInteger.valueOf(24007L))); + org.junit.Assert.assertTrue("'" + msg.states[27].sid.sat + "' != '" + 24007 + "'", value.equals(BigInteger.valueOf( 24007L ) ) ); } else { value = value.longValue(); expected = 24007L; @@ -1430,9 +958,7 @@ public void test1() throws Throwable { } value = msg.states[27].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[27].state + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.states[27].state + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; diff --git a/java/test/auto_check_sbp_tracking_MsgTrackingStateDetailedDepATest.java b/java/test/auto_check_sbp_tracking_MsgTrackingStateDetailedDepATest.java index 123a57980..2088e073f 100644 --- a/java/test/auto_check_sbp_tracking_MsgTrackingStateDetailedDepATest.java +++ b/java/test/auto_check_sbp_tracking_MsgTrackingStateDetailedDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingStateDetailedDepA.yaml by generate.py. Do -// not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingStateDetailedDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.tracking.MsgTrackingStateDetailedDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_tracking_MsgTrackingStateDetailedDepATest { @@ -29,77 +33,16 @@ public class auto_check_sbp_tracking_MsgTrackingStateDetailedDepATest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDetailedDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 46, - (byte) 31, - (byte) 180, - (byte) 38, - (byte) 219, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 133, - (byte) 100, - (byte) 71, - (byte) 94, - (byte) 192, - (byte) 2, - (byte) 160, - (byte) 207, - (byte) 212, - (byte) 255, - (byte) 135, - (byte) 139, - (byte) 62, - (byte) 62, - (byte) 179, - (byte) 83, - (byte) 227, - (byte) 245, - (byte) 134, - (byte) 160, - (byte) 204, - (byte) 78, - (byte) 95, - (byte) 255, - (byte) 38, - (byte) 59, - (byte) 161, - (byte) 15, - (byte) 255, - (byte) 86, - (byte) 189, - (byte) 248, - (byte) 31, - (byte) 191, - (byte) 136, - (byte) 194, - (byte) 124, - (byte) 23, - (byte) 15, - (byte) 91, - (byte) 249, - (byte) 117, - (byte) 142, - (byte) 90, - (byte) 219, - (byte) 67, - (byte) 25, - (byte) 83, - (byte) 62, - }; - SBPMessage sbp = new SBPMessage(0x6e9b, 0x21, payload); - MsgTrackingStateDetailedDepA msg = new MsgTrackingStateDetailedDepA(sbp); + System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDetailedDepATest.test1"); + byte[] payload = new byte[] {(byte)46,(byte)31,(byte)180,(byte)38,(byte)219,(byte)0,(byte)0,(byte)0,(byte)133,(byte)100,(byte)71,(byte)94,(byte)192,(byte)2,(byte)160,(byte)207,(byte)212,(byte)255,(byte)135,(byte)139,(byte)62,(byte)62,(byte)179,(byte)83,(byte)227,(byte)245,(byte)134,(byte)160,(byte)204,(byte)78,(byte)95,(byte)255,(byte)38,(byte)59,(byte)161,(byte)15,(byte)255,(byte)86,(byte)189,(byte)248,(byte)31,(byte)191,(byte)136,(byte)194,(byte)124,(byte)23,(byte)15,(byte)91,(byte)249,(byte)117,(byte)142,(byte)90,(byte)219,(byte)67,(byte)25,(byte)83,(byte)62, }; + SBPMessage sbp = new SBPMessage( 0x6e9b, 0x21, payload ); + MsgTrackingStateDetailedDepA msg = new MsgTrackingStateDetailedDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.L.f; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.L.f + "' != '" + 204 + "'", value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.L.f + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -107,9 +50,7 @@ public void test1() throws Throwable { } value = msg.L.i; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.L.i + "' != '" + -1601767965 + "'", - value.equals(BigInteger.valueOf(-1601767965L))); + org.junit.Assert.assertTrue("'" + msg.L.i + "' != '" + -1601767965 + "'", value.equals(BigInteger.valueOf( -1601767965L ) ) ); } else { value = value.longValue(); expected = -1601767965L; @@ -117,9 +58,7 @@ public void test1() throws Throwable { } value = msg.P; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.P + "' != '" + 1044286343 + "'", - value.equals(BigInteger.valueOf(1044286343L))); + org.junit.Assert.assertTrue("'" + msg.P + "' != '" + 1044286343 + "'", value.equals(BigInteger.valueOf( 1044286343L ) ) ); } else { value = value.longValue(); expected = 1044286343L; @@ -127,9 +66,7 @@ public void test1() throws Throwable { } value = msg.P_std; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.P_std + "' != '" + 21427 + "'", - value.equals(BigInteger.valueOf(21427L))); + org.junit.Assert.assertTrue("'" + msg.P_std + "' != '" + 21427 + "'", value.equals(BigInteger.valueOf( 21427L ) ) ); } else { value = value.longValue(); expected = 21427L; @@ -137,9 +74,7 @@ public void test1() throws Throwable { } value = msg.acceleration; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acceleration + "' != '" + -114 + "'", - value.equals(BigInteger.valueOf(-114L))); + org.junit.Assert.assertTrue("'" + msg.acceleration + "' != '" + -114 + "'", value.equals(BigInteger.valueOf( -114L ) ) ); } else { value = value.longValue(); expected = -114L; @@ -147,9 +82,7 @@ public void test1() throws Throwable { } value = msg.clock_drift; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.clock_drift + "' != '" + 23311 + "'", - value.equals(BigInteger.valueOf(23311L))); + org.junit.Assert.assertTrue("'" + msg.clock_drift + "' != '" + 23311 + "'", value.equals(BigInteger.valueOf( 23311L ) ) ); } else { value = value.longValue(); expected = 23311L; @@ -157,9 +90,7 @@ public void test1() throws Throwable { } value = msg.clock_offset; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.clock_offset + "' != '" + 6012 + "'", - value.equals(BigInteger.valueOf(6012L))); + org.junit.Assert.assertTrue("'" + msg.clock_offset + "' != '" + 6012 + "'", value.equals(BigInteger.valueOf( 6012L ) ) ); } else { value = value.longValue(); expected = 6012L; @@ -167,8 +98,7 @@ public void test1() throws Throwable { } value = msg.cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cn0 + "' != '" + 78 + "'", value.equals(BigInteger.valueOf(78L))); + org.junit.Assert.assertTrue("'" + msg.cn0 + "' != '" + 78 + "'", value.equals(BigInteger.valueOf( 78L ) ) ); } else { value = value.longValue(); expected = 78L; @@ -176,9 +106,7 @@ public void test1() throws Throwable { } value = msg.corr_spacing; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corr_spacing + "' != '" + 30201 + "'", - value.equals(BigInteger.valueOf(30201L))); + org.junit.Assert.assertTrue("'" + msg.corr_spacing + "' != '" + 30201 + "'", value.equals(BigInteger.valueOf( 30201L ) ) ); } else { value = value.longValue(); expected = 30201L; @@ -186,9 +114,7 @@ public void test1() throws Throwable { } value = msg.doppler; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.doppler + "' != '" + 1459556257 + "'", - value.equals(BigInteger.valueOf(1459556257L))); + org.junit.Assert.assertTrue("'" + msg.doppler + "' != '" + 1459556257 + "'", value.equals(BigInteger.valueOf( 1459556257L ) ) ); } else { value = value.longValue(); expected = 1459556257L; @@ -196,9 +122,7 @@ public void test1() throws Throwable { } value = msg.doppler_std; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.doppler_std + "' != '" + 63677 + "'", - value.equals(BigInteger.valueOf(63677L))); + org.junit.Assert.assertTrue("'" + msg.doppler_std + "' != '" + 63677 + "'", value.equals(BigInteger.valueOf( 63677L ) ) ); } else { value = value.longValue(); expected = 63677L; @@ -206,9 +130,7 @@ public void test1() throws Throwable { } value = msg.lock; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.lock + "' != '" + 65375 + "'", - value.equals(BigInteger.valueOf(65375L))); + org.junit.Assert.assertTrue("'" + msg.lock + "' != '" + 65375 + "'", value.equals(BigInteger.valueOf( 65375L ) ) ); } else { value = value.longValue(); expected = 65375L; @@ -216,9 +138,7 @@ public void test1() throws Throwable { } value = msg.misc_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.misc_flags + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.misc_flags + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -226,9 +146,7 @@ public void test1() throws Throwable { } value = msg.nav_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.nav_flags + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.nav_flags + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -236,9 +154,7 @@ public void test1() throws Throwable { } value = msg.pset_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pset_flags + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.pset_flags + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -246,9 +162,7 @@ public void test1() throws Throwable { } value = msg.recv_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.recv_time + "' != '" + 941247176494L + "'", - value.equals(new BigInteger("941247176494"))); + org.junit.Assert.assertTrue("'" + msg.recv_time + "' != '" + 941247176494L + "'", value.equals( new BigInteger( "941247176494" ) ) ); } else { value = value.longValue(); expected = 941247176494L; @@ -256,9 +170,7 @@ public void test1() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -266,8 +178,7 @@ public void test1() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 38 + "'", value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -275,9 +186,7 @@ public void test1() throws Throwable { } value = msg.sync_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sync_flags + "' != '" + 90 + "'", - value.equals(BigInteger.valueOf(90L))); + org.junit.Assert.assertTrue("'" + msg.sync_flags + "' != '" + 90 + "'", value.equals(BigInteger.valueOf( 90L ) ) ); } else { value = value.longValue(); expected = 90L; @@ -285,9 +194,7 @@ public void test1() throws Throwable { } value = msg.tot.ns_residual; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.ns_residual + "' != '" + -811597120 + "'", - value.equals(BigInteger.valueOf(-811597120L))); + org.junit.Assert.assertTrue("'" + msg.tot.ns_residual + "' != '" + -811597120 + "'", value.equals(BigInteger.valueOf( -811597120L ) ) ); } else { value = value.longValue(); expected = -811597120L; @@ -295,9 +202,7 @@ public void test1() throws Throwable { } value = msg.tot.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.tow + "' != '" + 1581737093 + "'", - value.equals(BigInteger.valueOf(1581737093L))); + org.junit.Assert.assertTrue("'" + msg.tot.tow + "' != '" + 1581737093 + "'", value.equals(BigInteger.valueOf( 1581737093L ) ) ); } else { value = value.longValue(); expected = 1581737093L; @@ -305,9 +210,7 @@ public void test1() throws Throwable { } value = msg.tot.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.wn + "' != '" + 65492 + "'", - value.equals(BigInteger.valueOf(65492L))); + org.junit.Assert.assertTrue("'" + msg.tot.wn + "' != '" + 65492 + "'", value.equals(BigInteger.valueOf( 65492L ) ) ); } else { value = value.longValue(); expected = 65492L; @@ -315,9 +218,7 @@ public void test1() throws Throwable { } value = msg.tow_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow_flags + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.tow_flags + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -325,9 +226,7 @@ public void test1() throws Throwable { } value = msg.track_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.track_flags + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.track_flags + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -335,9 +234,7 @@ public void test1() throws Throwable { } value = msg.uptime; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uptime + "' != '" + 3263741727L + "'", - value.equals(new BigInteger("3263741727"))); + org.junit.Assert.assertTrue("'" + msg.uptime + "' != '" + 3263741727L + "'", value.equals( new BigInteger( "3263741727" ) ) ); } else { value = value.longValue(); expected = 3263741727L; diff --git a/java/test/auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.java b/java/test/auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.java index 6e8b7e9bf..e2a1836c2 100644 --- a/java/test/auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.java +++ b/java/test/auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingStateDetailedDep.yaml by generate.py. Do -// not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingStateDetailedDep.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.tracking.MsgTrackingStateDetailedDep; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest { @@ -29,75 +33,16 @@ public class auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest { @Test public void test1() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.test1"); - byte[] payload = - new byte[] { - (byte) 163, - (byte) 151, - (byte) 112, - (byte) 215, - (byte) 1, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 39, - (byte) 5, - (byte) 0, - (byte) 0, - (byte) 169, - (byte) 177, - (byte) 208, - (byte) 54, - (byte) 15, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 85, - (byte) 61, - (byte) 0, - (byte) 0, - (byte) 39, - (byte) 0, - (byte) 1, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 40, - (byte) 0, - (byte) 108, - (byte) 1, - (byte) 0, - (byte) 11, - (byte) 0, - (byte) 0, - (byte) 9, - }; - SBPMessage sbp = new SBPMessage(0x673b, 0x11, payload); - MsgTrackingStateDetailedDep msg = new MsgTrackingStateDetailedDep(sbp); + System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.test1"); + byte[] payload = new byte[] {(byte)163,(byte)151,(byte)112,(byte)215,(byte)1,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)39,(byte)5,(byte)0,(byte)0,(byte)169,(byte)177,(byte)208,(byte)54,(byte)15,(byte)0,(byte)0,(byte)0,(byte)85,(byte)61,(byte)0,(byte)0,(byte)39,(byte)0,(byte)1,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)40,(byte)0,(byte)108,(byte)1,(byte)0,(byte)11,(byte)0,(byte)0,(byte)9, }; + SBPMessage sbp = new SBPMessage( 0x673b, 0x11, payload ); + MsgTrackingStateDetailedDep msg = new MsgTrackingStateDetailedDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.L.f; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.L.f + "' != '" + 169 + "'", value.equals(BigInteger.valueOf(169L))); + org.junit.Assert.assertTrue("'" + msg.L.f + "' != '" + 169 + "'", value.equals(BigInteger.valueOf( 169L ) ) ); } else { value = value.longValue(); expected = 169L; @@ -105,8 +50,7 @@ public void test1() throws Throwable { } value = msg.L.i; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.L.i + "' != '" + 1319 + "'", value.equals(BigInteger.valueOf(1319L))); + org.junit.Assert.assertTrue("'" + msg.L.i + "' != '" + 1319 + "'", value.equals(BigInteger.valueOf( 1319L ) ) ); } else { value = value.longValue(); expected = 1319L; @@ -114,8 +58,7 @@ public void test1() throws Throwable { } value = msg.P; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.P + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.P + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -123,8 +66,7 @@ public void test1() throws Throwable { } value = msg.P_std; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.P_std + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.P_std + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -132,9 +74,7 @@ public void test1() throws Throwable { } value = msg.acceleration; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acceleration + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.acceleration + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -142,9 +82,7 @@ public void test1() throws Throwable { } value = msg.clock_drift; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.clock_drift + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.clock_drift + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -152,9 +90,7 @@ public void test1() throws Throwable { } value = msg.clock_offset; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.clock_offset + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.clock_offset + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -162,8 +98,7 @@ public void test1() throws Throwable { } value = msg.cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cn0 + "' != '" + 177 + "'", value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.cn0 + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -171,9 +106,7 @@ public void test1() throws Throwable { } value = msg.corr_spacing; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corr_spacing + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.corr_spacing + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -181,9 +114,7 @@ public void test1() throws Throwable { } value = msg.doppler; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.doppler + "' != '" + 15701 + "'", - value.equals(BigInteger.valueOf(15701L))); + org.junit.Assert.assertTrue("'" + msg.doppler + "' != '" + 15701 + "'", value.equals(BigInteger.valueOf( 15701L ) ) ); } else { value = value.longValue(); expected = 15701L; @@ -191,9 +122,7 @@ public void test1() throws Throwable { } value = msg.doppler_std; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.doppler_std + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.doppler_std + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -201,9 +130,7 @@ public void test1() throws Throwable { } value = msg.lock; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.lock + "' != '" + 14032 + "'", - value.equals(BigInteger.valueOf(14032L))); + org.junit.Assert.assertTrue("'" + msg.lock + "' != '" + 14032 + "'", value.equals(BigInteger.valueOf( 14032L ) ) ); } else { value = value.longValue(); expected = 14032L; @@ -211,9 +138,7 @@ public void test1() throws Throwable { } value = msg.misc_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.misc_flags + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.misc_flags + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -221,8 +146,7 @@ public void test1() throws Throwable { } value = msg.nav_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.nav_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.nav_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -230,9 +154,7 @@ public void test1() throws Throwable { } value = msg.pset_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pset_flags + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.pset_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -240,9 +162,7 @@ public void test1() throws Throwable { } value = msg.recv_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.recv_time + "' != '" + 7909447587L + "'", - value.equals(new BigInteger("7909447587"))); + org.junit.Assert.assertTrue("'" + msg.recv_time + "' != '" + 7909447587L + "'", value.equals( new BigInteger( "7909447587" ) ) ); } else { value = value.longValue(); expected = 7909447587L; @@ -250,8 +170,7 @@ public void test1() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -259,9 +178,7 @@ public void test1() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -269,8 +186,7 @@ public void test1() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -278,9 +194,7 @@ public void test1() throws Throwable { } value = msg.sync_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sync_flags + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sync_flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -288,8 +202,7 @@ public void test1() throws Throwable { } value = msg.tot.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.tow + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tot.tow + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -297,8 +210,7 @@ public void test1() throws Throwable { } value = msg.tot.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.wn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tot.wn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -306,8 +218,7 @@ public void test1() throws Throwable { } value = msg.tow_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tow_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -315,9 +226,7 @@ public void test1() throws Throwable { } value = msg.track_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.track_flags + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.track_flags + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -325,8 +234,7 @@ public void test1() throws Throwable { } value = msg.uptime; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uptime + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.uptime + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -339,75 +247,16 @@ public void test1() throws Throwable { @Test public void test2() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.test2"); - byte[] payload = - new byte[] { - (byte) 97, - (byte) 251, - (byte) 61, - (byte) 245, - (byte) 1, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 18, - (byte) 7, - (byte) 0, - (byte) 0, - (byte) 14, - (byte) 175, - (byte) 208, - (byte) 54, - (byte) 15, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 51, - (byte) 61, - (byte) 0, - (byte) 0, - (byte) 30, - (byte) 0, - (byte) 1, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 40, - (byte) 0, - (byte) 224, - (byte) 1, - (byte) 0, - (byte) 11, - (byte) 0, - (byte) 0, - (byte) 9, - }; - SBPMessage sbp = new SBPMessage(0x673b, 0x11, payload); - MsgTrackingStateDetailedDep msg = new MsgTrackingStateDetailedDep(sbp); + System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.test2"); + byte[] payload = new byte[] {(byte)97,(byte)251,(byte)61,(byte)245,(byte)1,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)18,(byte)7,(byte)0,(byte)0,(byte)14,(byte)175,(byte)208,(byte)54,(byte)15,(byte)0,(byte)0,(byte)0,(byte)51,(byte)61,(byte)0,(byte)0,(byte)30,(byte)0,(byte)1,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)40,(byte)0,(byte)224,(byte)1,(byte)0,(byte)11,(byte)0,(byte)0,(byte)9, }; + SBPMessage sbp = new SBPMessage( 0x673b, 0x11, payload ); + MsgTrackingStateDetailedDep msg = new MsgTrackingStateDetailedDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.L.f; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.L.f + "' != '" + 14 + "'", value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.L.f + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -415,8 +264,7 @@ public void test2() throws Throwable { } value = msg.L.i; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.L.i + "' != '" + 1810 + "'", value.equals(BigInteger.valueOf(1810L))); + org.junit.Assert.assertTrue("'" + msg.L.i + "' != '" + 1810 + "'", value.equals(BigInteger.valueOf( 1810L ) ) ); } else { value = value.longValue(); expected = 1810L; @@ -424,8 +272,7 @@ public void test2() throws Throwable { } value = msg.P; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.P + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.P + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -433,8 +280,7 @@ public void test2() throws Throwable { } value = msg.P_std; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.P_std + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.P_std + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -442,9 +288,7 @@ public void test2() throws Throwable { } value = msg.acceleration; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acceleration + "' != '" + -32 + "'", - value.equals(BigInteger.valueOf(-32L))); + org.junit.Assert.assertTrue("'" + msg.acceleration + "' != '" + -32 + "'", value.equals(BigInteger.valueOf( -32L ) ) ); } else { value = value.longValue(); expected = -32L; @@ -452,9 +296,7 @@ public void test2() throws Throwable { } value = msg.clock_drift; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.clock_drift + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.clock_drift + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -462,9 +304,7 @@ public void test2() throws Throwable { } value = msg.clock_offset; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.clock_offset + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.clock_offset + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -472,8 +312,7 @@ public void test2() throws Throwable { } value = msg.cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cn0 + "' != '" + 175 + "'", value.equals(BigInteger.valueOf(175L))); + org.junit.Assert.assertTrue("'" + msg.cn0 + "' != '" + 175 + "'", value.equals(BigInteger.valueOf( 175L ) ) ); } else { value = value.longValue(); expected = 175L; @@ -481,9 +320,7 @@ public void test2() throws Throwable { } value = msg.corr_spacing; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corr_spacing + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.corr_spacing + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -491,9 +328,7 @@ public void test2() throws Throwable { } value = msg.doppler; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.doppler + "' != '" + 15667 + "'", - value.equals(BigInteger.valueOf(15667L))); + org.junit.Assert.assertTrue("'" + msg.doppler + "' != '" + 15667 + "'", value.equals(BigInteger.valueOf( 15667L ) ) ); } else { value = value.longValue(); expected = 15667L; @@ -501,9 +336,7 @@ public void test2() throws Throwable { } value = msg.doppler_std; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.doppler_std + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.doppler_std + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -511,9 +344,7 @@ public void test2() throws Throwable { } value = msg.lock; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.lock + "' != '" + 14032 + "'", - value.equals(BigInteger.valueOf(14032L))); + org.junit.Assert.assertTrue("'" + msg.lock + "' != '" + 14032 + "'", value.equals(BigInteger.valueOf( 14032L ) ) ); } else { value = value.longValue(); expected = 14032L; @@ -521,9 +352,7 @@ public void test2() throws Throwable { } value = msg.misc_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.misc_flags + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.misc_flags + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -531,8 +360,7 @@ public void test2() throws Throwable { } value = msg.nav_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.nav_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.nav_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -540,9 +368,7 @@ public void test2() throws Throwable { } value = msg.pset_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pset_flags + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.pset_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -550,9 +376,7 @@ public void test2() throws Throwable { } value = msg.recv_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.recv_time + "' != '" + 8409447265L + "'", - value.equals(new BigInteger("8409447265"))); + org.junit.Assert.assertTrue("'" + msg.recv_time + "' != '" + 8409447265L + "'", value.equals( new BigInteger( "8409447265" ) ) ); } else { value = value.longValue(); expected = 8409447265L; @@ -560,8 +384,7 @@ public void test2() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -569,9 +392,7 @@ public void test2() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -579,8 +400,7 @@ public void test2() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -588,9 +408,7 @@ public void test2() throws Throwable { } value = msg.sync_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sync_flags + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sync_flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -598,8 +416,7 @@ public void test2() throws Throwable { } value = msg.tot.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.tow + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tot.tow + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -607,8 +424,7 @@ public void test2() throws Throwable { } value = msg.tot.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.wn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tot.wn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -616,8 +432,7 @@ public void test2() throws Throwable { } value = msg.tow_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tow_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -625,9 +440,7 @@ public void test2() throws Throwable { } value = msg.track_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.track_flags + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.track_flags + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -635,8 +448,7 @@ public void test2() throws Throwable { } value = msg.uptime; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uptime + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.uptime + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -649,75 +461,16 @@ public void test2() throws Throwable { @Test public void test3() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.test3"); - byte[] payload = - new byte[] { - (byte) 139, - (byte) 218, - (byte) 236, - (byte) 18, - (byte) 2, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 250, - (byte) 8, - (byte) 0, - (byte) 0, - (byte) 8, - (byte) 179, - (byte) 208, - (byte) 54, - (byte) 15, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 67, - (byte) 61, - (byte) 0, - (byte) 0, - (byte) 22, - (byte) 0, - (byte) 2, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 40, - (byte) 0, - (byte) 27, - (byte) 1, - (byte) 0, - (byte) 11, - (byte) 0, - (byte) 2, - (byte) 9, - }; - SBPMessage sbp = new SBPMessage(0x673b, 0x11, payload); - MsgTrackingStateDetailedDep msg = new MsgTrackingStateDetailedDep(sbp); + System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.test3"); + byte[] payload = new byte[] {(byte)139,(byte)218,(byte)236,(byte)18,(byte)2,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)250,(byte)8,(byte)0,(byte)0,(byte)8,(byte)179,(byte)208,(byte)54,(byte)15,(byte)0,(byte)0,(byte)0,(byte)67,(byte)61,(byte)0,(byte)0,(byte)22,(byte)0,(byte)2,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)40,(byte)0,(byte)27,(byte)1,(byte)0,(byte)11,(byte)0,(byte)2,(byte)9, }; + SBPMessage sbp = new SBPMessage( 0x673b, 0x11, payload ); + MsgTrackingStateDetailedDep msg = new MsgTrackingStateDetailedDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.L.f; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.L.f + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.L.f + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -725,8 +478,7 @@ public void test3() throws Throwable { } value = msg.L.i; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.L.i + "' != '" + 2298 + "'", value.equals(BigInteger.valueOf(2298L))); + org.junit.Assert.assertTrue("'" + msg.L.i + "' != '" + 2298 + "'", value.equals(BigInteger.valueOf( 2298L ) ) ); } else { value = value.longValue(); expected = 2298L; @@ -734,8 +486,7 @@ public void test3() throws Throwable { } value = msg.P; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.P + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.P + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -743,8 +494,7 @@ public void test3() throws Throwable { } value = msg.P_std; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.P_std + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.P_std + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -752,9 +502,7 @@ public void test3() throws Throwable { } value = msg.acceleration; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acceleration + "' != '" + 27 + "'", - value.equals(BigInteger.valueOf(27L))); + org.junit.Assert.assertTrue("'" + msg.acceleration + "' != '" + 27 + "'", value.equals(BigInteger.valueOf( 27L ) ) ); } else { value = value.longValue(); expected = 27L; @@ -762,9 +510,7 @@ public void test3() throws Throwable { } value = msg.clock_drift; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.clock_drift + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.clock_drift + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -772,9 +518,7 @@ public void test3() throws Throwable { } value = msg.clock_offset; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.clock_offset + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.clock_offset + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -782,8 +526,7 @@ public void test3() throws Throwable { } value = msg.cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cn0 + "' != '" + 179 + "'", value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.cn0 + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -791,9 +534,7 @@ public void test3() throws Throwable { } value = msg.corr_spacing; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corr_spacing + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.corr_spacing + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -801,9 +542,7 @@ public void test3() throws Throwable { } value = msg.doppler; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.doppler + "' != '" + 15683 + "'", - value.equals(BigInteger.valueOf(15683L))); + org.junit.Assert.assertTrue("'" + msg.doppler + "' != '" + 15683 + "'", value.equals(BigInteger.valueOf( 15683L ) ) ); } else { value = value.longValue(); expected = 15683L; @@ -811,9 +550,7 @@ public void test3() throws Throwable { } value = msg.doppler_std; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.doppler_std + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.doppler_std + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -821,9 +558,7 @@ public void test3() throws Throwable { } value = msg.lock; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.lock + "' != '" + 14032 + "'", - value.equals(BigInteger.valueOf(14032L))); + org.junit.Assert.assertTrue("'" + msg.lock + "' != '" + 14032 + "'", value.equals(BigInteger.valueOf( 14032L ) ) ); } else { value = value.longValue(); expected = 14032L; @@ -831,9 +566,7 @@ public void test3() throws Throwable { } value = msg.misc_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.misc_flags + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.misc_flags + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -841,8 +574,7 @@ public void test3() throws Throwable { } value = msg.nav_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.nav_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.nav_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -850,9 +582,7 @@ public void test3() throws Throwable { } value = msg.pset_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pset_flags + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.pset_flags + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -860,9 +590,7 @@ public void test3() throws Throwable { } value = msg.recv_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.recv_time + "' != '" + 8907446923L + "'", - value.equals(new BigInteger("8907446923"))); + org.junit.Assert.assertTrue("'" + msg.recv_time + "' != '" + 8907446923L + "'", value.equals( new BigInteger( "8907446923" ) ) ); } else { value = value.longValue(); expected = 8907446923L; @@ -870,8 +598,7 @@ public void test3() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -879,9 +606,7 @@ public void test3() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -889,8 +614,7 @@ public void test3() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -898,9 +622,7 @@ public void test3() throws Throwable { } value = msg.sync_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sync_flags + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sync_flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -908,8 +630,7 @@ public void test3() throws Throwable { } value = msg.tot.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.tow + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tot.tow + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -917,8 +638,7 @@ public void test3() throws Throwable { } value = msg.tot.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.wn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tot.wn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -926,8 +646,7 @@ public void test3() throws Throwable { } value = msg.tow_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tow_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -935,9 +654,7 @@ public void test3() throws Throwable { } value = msg.track_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.track_flags + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.track_flags + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -945,8 +662,7 @@ public void test3() throws Throwable { } value = msg.uptime; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uptime + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.uptime + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -959,75 +675,16 @@ public void test3() throws Throwable { @Test public void test4() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.test4"); - byte[] payload = - new byte[] { - (byte) 255, - (byte) 251, - (byte) 170, - (byte) 48, - (byte) 2, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 226, - (byte) 10, - (byte) 0, - (byte) 0, - (byte) 125, - (byte) 181, - (byte) 208, - (byte) 54, - (byte) 15, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 29, - (byte) 61, - (byte) 0, - (byte) 0, - (byte) 10, - (byte) 0, - (byte) 2, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 40, - (byte) 0, - (byte) 220, - (byte) 1, - (byte) 0, - (byte) 11, - (byte) 0, - (byte) 3, - (byte) 9, - }; - SBPMessage sbp = new SBPMessage(0x673b, 0x11, payload); - MsgTrackingStateDetailedDep msg = new MsgTrackingStateDetailedDep(sbp); + System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.test4"); + byte[] payload = new byte[] {(byte)255,(byte)251,(byte)170,(byte)48,(byte)2,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)226,(byte)10,(byte)0,(byte)0,(byte)125,(byte)181,(byte)208,(byte)54,(byte)15,(byte)0,(byte)0,(byte)0,(byte)29,(byte)61,(byte)0,(byte)0,(byte)10,(byte)0,(byte)2,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)40,(byte)0,(byte)220,(byte)1,(byte)0,(byte)11,(byte)0,(byte)3,(byte)9, }; + SBPMessage sbp = new SBPMessage( 0x673b, 0x11, payload ); + MsgTrackingStateDetailedDep msg = new MsgTrackingStateDetailedDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.L.f; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.L.f + "' != '" + 125 + "'", value.equals(BigInteger.valueOf(125L))); + org.junit.Assert.assertTrue("'" + msg.L.f + "' != '" + 125 + "'", value.equals(BigInteger.valueOf( 125L ) ) ); } else { value = value.longValue(); expected = 125L; @@ -1035,8 +692,7 @@ public void test4() throws Throwable { } value = msg.L.i; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.L.i + "' != '" + 2786 + "'", value.equals(BigInteger.valueOf(2786L))); + org.junit.Assert.assertTrue("'" + msg.L.i + "' != '" + 2786 + "'", value.equals(BigInteger.valueOf( 2786L ) ) ); } else { value = value.longValue(); expected = 2786L; @@ -1044,8 +700,7 @@ public void test4() throws Throwable { } value = msg.P; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.P + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.P + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1053,8 +708,7 @@ public void test4() throws Throwable { } value = msg.P_std; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.P_std + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.P_std + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1062,9 +716,7 @@ public void test4() throws Throwable { } value = msg.acceleration; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acceleration + "' != '" + -36 + "'", - value.equals(BigInteger.valueOf(-36L))); + org.junit.Assert.assertTrue("'" + msg.acceleration + "' != '" + -36 + "'", value.equals(BigInteger.valueOf( -36L ) ) ); } else { value = value.longValue(); expected = -36L; @@ -1072,9 +724,7 @@ public void test4() throws Throwable { } value = msg.clock_drift; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.clock_drift + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.clock_drift + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1082,9 +732,7 @@ public void test4() throws Throwable { } value = msg.clock_offset; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.clock_offset + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.clock_offset + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1092,8 +740,7 @@ public void test4() throws Throwable { } value = msg.cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cn0 + "' != '" + 181 + "'", value.equals(BigInteger.valueOf(181L))); + org.junit.Assert.assertTrue("'" + msg.cn0 + "' != '" + 181 + "'", value.equals(BigInteger.valueOf( 181L ) ) ); } else { value = value.longValue(); expected = 181L; @@ -1101,9 +748,7 @@ public void test4() throws Throwable { } value = msg.corr_spacing; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corr_spacing + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.corr_spacing + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -1111,9 +756,7 @@ public void test4() throws Throwable { } value = msg.doppler; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.doppler + "' != '" + 15645 + "'", - value.equals(BigInteger.valueOf(15645L))); + org.junit.Assert.assertTrue("'" + msg.doppler + "' != '" + 15645 + "'", value.equals(BigInteger.valueOf( 15645L ) ) ); } else { value = value.longValue(); expected = 15645L; @@ -1121,9 +764,7 @@ public void test4() throws Throwable { } value = msg.doppler_std; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.doppler_std + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.doppler_std + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -1131,9 +772,7 @@ public void test4() throws Throwable { } value = msg.lock; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.lock + "' != '" + 14032 + "'", - value.equals(BigInteger.valueOf(14032L))); + org.junit.Assert.assertTrue("'" + msg.lock + "' != '" + 14032 + "'", value.equals(BigInteger.valueOf( 14032L ) ) ); } else { value = value.longValue(); expected = 14032L; @@ -1141,9 +780,7 @@ public void test4() throws Throwable { } value = msg.misc_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.misc_flags + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.misc_flags + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -1151,8 +788,7 @@ public void test4() throws Throwable { } value = msg.nav_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.nav_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.nav_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1160,9 +796,7 @@ public void test4() throws Throwable { } value = msg.pset_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pset_flags + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.pset_flags + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1170,9 +804,7 @@ public void test4() throws Throwable { } value = msg.recv_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.recv_time + "' != '" + 9406446591L + "'", - value.equals(new BigInteger("9406446591"))); + org.junit.Assert.assertTrue("'" + msg.recv_time + "' != '" + 9406446591L + "'", value.equals( new BigInteger( "9406446591" ) ) ); } else { value = value.longValue(); expected = 9406446591L; @@ -1180,8 +812,7 @@ public void test4() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1189,9 +820,7 @@ public void test4() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1199,8 +828,7 @@ public void test4() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -1208,9 +836,7 @@ public void test4() throws Throwable { } value = msg.sync_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sync_flags + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sync_flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1218,8 +844,7 @@ public void test4() throws Throwable { } value = msg.tot.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.tow + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tot.tow + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1227,8 +852,7 @@ public void test4() throws Throwable { } value = msg.tot.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.wn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tot.wn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1236,8 +860,7 @@ public void test4() throws Throwable { } value = msg.tow_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tow_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1245,9 +868,7 @@ public void test4() throws Throwable { } value = msg.track_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.track_flags + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.track_flags + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -1255,8 +876,7 @@ public void test4() throws Throwable { } value = msg.uptime; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uptime + "' != '" + 2 + "'", value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.uptime + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1269,75 +889,16 @@ public void test4() throws Throwable { @Test public void test5() throws Throwable { if (debug) - System.out.format( - "%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.test5"); - byte[] payload = - new byte[] { - (byte) 189, - (byte) 95, - (byte) 120, - (byte) 78, - (byte) 2, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 203, - (byte) 12, - (byte) 0, - (byte) 0, - (byte) 64, - (byte) 184, - (byte) 208, - (byte) 54, - (byte) 15, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 24, - (byte) 61, - (byte) 0, - (byte) 0, - (byte) 4, - (byte) 0, - (byte) 3, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 0, - (byte) 40, - (byte) 0, - (byte) 2, - (byte) 1, - (byte) 0, - (byte) 11, - (byte) 0, - (byte) 3, - (byte) 9, - }; - SBPMessage sbp = new SBPMessage(0x673b, 0x11, payload); - MsgTrackingStateDetailedDep msg = new MsgTrackingStateDetailedDep(sbp); + System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateDetailedDepTest.test5"); + byte[] payload = new byte[] {(byte)189,(byte)95,(byte)120,(byte)78,(byte)2,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)203,(byte)12,(byte)0,(byte)0,(byte)64,(byte)184,(byte)208,(byte)54,(byte)15,(byte)0,(byte)0,(byte)0,(byte)24,(byte)61,(byte)0,(byte)0,(byte)4,(byte)0,(byte)3,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)40,(byte)0,(byte)2,(byte)1,(byte)0,(byte)11,(byte)0,(byte)3,(byte)9, }; + SBPMessage sbp = new SBPMessage( 0x673b, 0x11, payload ); + MsgTrackingStateDetailedDep msg = new MsgTrackingStateDetailedDep( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.L.f; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.L.f + "' != '" + 64 + "'", value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.L.f + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -1345,8 +906,7 @@ public void test5() throws Throwable { } value = msg.L.i; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.L.i + "' != '" + 3275 + "'", value.equals(BigInteger.valueOf(3275L))); + org.junit.Assert.assertTrue("'" + msg.L.i + "' != '" + 3275 + "'", value.equals(BigInteger.valueOf( 3275L ) ) ); } else { value = value.longValue(); expected = 3275L; @@ -1354,8 +914,7 @@ public void test5() throws Throwable { } value = msg.P; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.P + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.P + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1363,8 +922,7 @@ public void test5() throws Throwable { } value = msg.P_std; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.P_std + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.P_std + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1372,9 +930,7 @@ public void test5() throws Throwable { } value = msg.acceleration; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.acceleration + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.acceleration + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1382,9 +938,7 @@ public void test5() throws Throwable { } value = msg.clock_drift; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.clock_drift + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.clock_drift + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1392,9 +946,7 @@ public void test5() throws Throwable { } value = msg.clock_offset; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.clock_offset + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.clock_offset + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1402,8 +954,7 @@ public void test5() throws Throwable { } value = msg.cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.cn0 + "' != '" + 184 + "'", value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.cn0 + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -1411,9 +962,7 @@ public void test5() throws Throwable { } value = msg.corr_spacing; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.corr_spacing + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.corr_spacing + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -1421,9 +970,7 @@ public void test5() throws Throwable { } value = msg.doppler; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.doppler + "' != '" + 15640 + "'", - value.equals(BigInteger.valueOf(15640L))); + org.junit.Assert.assertTrue("'" + msg.doppler + "' != '" + 15640 + "'", value.equals(BigInteger.valueOf( 15640L ) ) ); } else { value = value.longValue(); expected = 15640L; @@ -1431,9 +978,7 @@ public void test5() throws Throwable { } value = msg.doppler_std; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.doppler_std + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.doppler_std + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1441,9 +986,7 @@ public void test5() throws Throwable { } value = msg.lock; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.lock + "' != '" + 14032 + "'", - value.equals(BigInteger.valueOf(14032L))); + org.junit.Assert.assertTrue("'" + msg.lock + "' != '" + 14032 + "'", value.equals(BigInteger.valueOf( 14032L ) ) ); } else { value = value.longValue(); expected = 14032L; @@ -1451,9 +994,7 @@ public void test5() throws Throwable { } value = msg.misc_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.misc_flags + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.misc_flags + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -1461,8 +1002,7 @@ public void test5() throws Throwable { } value = msg.nav_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.nav_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.nav_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1470,9 +1010,7 @@ public void test5() throws Throwable { } value = msg.pset_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.pset_flags + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.pset_flags + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1480,9 +1018,7 @@ public void test5() throws Throwable { } value = msg.recv_time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.recv_time + "' != '" + 9906446269L + "'", - value.equals(new BigInteger("9906446269"))); + org.junit.Assert.assertTrue("'" + msg.recv_time + "' != '" + 9906446269L + "'", value.equals( new BigInteger( "9906446269" ) ) ); } else { value = value.longValue(); expected = 9906446269L; @@ -1490,8 +1026,7 @@ public void test5() throws Throwable { } value = msg.sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1499,9 +1034,7 @@ public void test5() throws Throwable { } value = msg.sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1509,8 +1042,7 @@ public void test5() throws Throwable { } value = msg.sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.sid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -1518,9 +1050,7 @@ public void test5() throws Throwable { } value = msg.sync_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.sync_flags + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.sync_flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1528,8 +1058,7 @@ public void test5() throws Throwable { } value = msg.tot.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.tow + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tot.tow + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1537,8 +1066,7 @@ public void test5() throws Throwable { } value = msg.tot.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tot.wn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tot.wn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1546,8 +1074,7 @@ public void test5() throws Throwable { } value = msg.tow_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.tow_flags + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1555,9 +1082,7 @@ public void test5() throws Throwable { } value = msg.track_flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.track_flags + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.track_flags + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -1565,8 +1090,7 @@ public void test5() throws Throwable { } value = msg.uptime; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.uptime + "' != '" + 3 + "'", value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.uptime + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; diff --git a/java/test/auto_check_sbp_tracking_MsgTrackingStateTest.java b/java/test/auto_check_sbp_tracking_MsgTrackingStateTest.java index 8ff1cb3ec..76538b46b 100644 --- a/java/test/auto_check_sbp_tracking_MsgTrackingStateTest.java +++ b/java/test/auto_check_sbp_tracking_MsgTrackingStateTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,19 +9,23 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingState.yaml by generate.py. Do not modify by -// hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/tracking/test_MsgTrackingState.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.tracking.MsgTrackingState; + import com.swiftnav.sbp.tracking.MsgTrackingStateDepB; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_tracking_MsgTrackingStateTest { @@ -31,271 +36,15 @@ public class auto_check_sbp_tracking_MsgTrackingStateTest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateTest.test1"); - byte[] payload = - new byte[] { - (byte) 117, - (byte) 184, - (byte) 3, - (byte) 102, - (byte) 38, - (byte) 106, - (byte) 140, - (byte) 141, - (byte) 25, - (byte) 4, - (byte) 90, - (byte) 195, - (byte) 246, - (byte) 108, - (byte) 75, - (byte) 82, - (byte) 137, - (byte) 127, - (byte) 45, - (byte) 163, - (byte) 32, - (byte) 46, - (byte) 187, - (byte) 93, - (byte) 153, - (byte) 60, - (byte) 201, - (byte) 147, - (byte) 23, - (byte) 29, - (byte) 5, - (byte) 208, - (byte) 181, - (byte) 30, - (byte) 219, - (byte) 69, - (byte) 254, - (byte) 136, - (byte) 3, - (byte) 121, - (byte) 33, - (byte) 98, - (byte) 144, - (byte) 215, - (byte) 133, - (byte) 182, - (byte) 14, - (byte) 56, - (byte) 169, - (byte) 77, - (byte) 218, - (byte) 62, - (byte) 242, - (byte) 84, - (byte) 171, - (byte) 249, - (byte) 152, - (byte) 137, - (byte) 131, - (byte) 130, - (byte) 193, - (byte) 21, - (byte) 42, - (byte) 68, - (byte) 253, - (byte) 227, - (byte) 216, - (byte) 227, - (byte) 24, - (byte) 26, - (byte) 210, - (byte) 179, - (byte) 19, - (byte) 15, - (byte) 227, - (byte) 255, - (byte) 122, - (byte) 75, - (byte) 187, - (byte) 200, - (byte) 217, - (byte) 48, - (byte) 218, - (byte) 122, - (byte) 187, - (byte) 238, - (byte) 142, - (byte) 149, - (byte) 238, - (byte) 55, - (byte) 251, - (byte) 212, - (byte) 128, - (byte) 160, - (byte) 194, - (byte) 104, - (byte) 113, - (byte) 255, - (byte) 141, - (byte) 62, - (byte) 43, - (byte) 69, - (byte) 245, - (byte) 39, - (byte) 100, - (byte) 230, - (byte) 108, - (byte) 56, - (byte) 247, - (byte) 68, - (byte) 149, - (byte) 143, - (byte) 137, - (byte) 101, - (byte) 233, - (byte) 70, - (byte) 49, - (byte) 165, - (byte) 38, - (byte) 110, - (byte) 218, - (byte) 230, - (byte) 80, - (byte) 213, - (byte) 196, - (byte) 179, - (byte) 139, - (byte) 128, - (byte) 15, - (byte) 178, - (byte) 196, - (byte) 171, - (byte) 8, - (byte) 212, - (byte) 97, - (byte) 194, - (byte) 83, - (byte) 233, - (byte) 79, - (byte) 99, - (byte) 55, - (byte) 90, - (byte) 31, - (byte) 180, - (byte) 5, - (byte) 25, - (byte) 105, - (byte) 186, - (byte) 22, - (byte) 224, - (byte) 80, - (byte) 111, - (byte) 8, - (byte) 48, - (byte) 106, - (byte) 166, - (byte) 4, - (byte) 48, - (byte) 156, - (byte) 49, - (byte) 86, - (byte) 19, - (byte) 142, - (byte) 146, - (byte) 91, - (byte) 124, - (byte) 115, - (byte) 64, - (byte) 28, - (byte) 230, - (byte) 115, - (byte) 178, - (byte) 190, - (byte) 131, - (byte) 16, - (byte) 242, - (byte) 105, - (byte) 59, - (byte) 182, - (byte) 113, - (byte) 192, - (byte) 180, - (byte) 48, - (byte) 179, - (byte) 166, - (byte) 31, - (byte) 172, - (byte) 211, - (byte) 77, - (byte) 228, - (byte) 140, - (byte) 49, - (byte) 128, - (byte) 77, - (byte) 240, - (byte) 194, - (byte) 134, - (byte) 194, - (byte) 41, - (byte) 58, - (byte) 18, - (byte) 53, - (byte) 129, - (byte) 55, - (byte) 91, - (byte) 72, - (byte) 134, - (byte) 92, - (byte) 33, - (byte) 224, - (byte) 157, - (byte) 56, - (byte) 186, - (byte) 54, - (byte) 224, - (byte) 174, - (byte) 82, - (byte) 84, - (byte) 148, - (byte) 190, - (byte) 236, - (byte) 54, - (byte) 62, - (byte) 67, - (byte) 52, - (byte) 215, - (byte) 57, - (byte) 254, - (byte) 16, - (byte) 133, - (byte) 36, - (byte) 174, - (byte) 219, - (byte) 172, - (byte) 145, - (byte) 17, - (byte) 192, - (byte) 179, - (byte) 111, - (byte) 97, - (byte) 207, - (byte) 56, - (byte) 208, - (byte) 134, - (byte) 180, - (byte) 17, - (byte) 43, - (byte) 226, - (byte) 255, - (byte) 182, - (byte) 140, - (byte) 113, - }; - SBPMessage sbp = new SBPMessage(0x8137, 0x41, payload); - MsgTrackingState msg = new MsgTrackingState(sbp); + byte[] payload = new byte[] {(byte)117,(byte)184,(byte)3,(byte)102,(byte)38,(byte)106,(byte)140,(byte)141,(byte)25,(byte)4,(byte)90,(byte)195,(byte)246,(byte)108,(byte)75,(byte)82,(byte)137,(byte)127,(byte)45,(byte)163,(byte)32,(byte)46,(byte)187,(byte)93,(byte)153,(byte)60,(byte)201,(byte)147,(byte)23,(byte)29,(byte)5,(byte)208,(byte)181,(byte)30,(byte)219,(byte)69,(byte)254,(byte)136,(byte)3,(byte)121,(byte)33,(byte)98,(byte)144,(byte)215,(byte)133,(byte)182,(byte)14,(byte)56,(byte)169,(byte)77,(byte)218,(byte)62,(byte)242,(byte)84,(byte)171,(byte)249,(byte)152,(byte)137,(byte)131,(byte)130,(byte)193,(byte)21,(byte)42,(byte)68,(byte)253,(byte)227,(byte)216,(byte)227,(byte)24,(byte)26,(byte)210,(byte)179,(byte)19,(byte)15,(byte)227,(byte)255,(byte)122,(byte)75,(byte)187,(byte)200,(byte)217,(byte)48,(byte)218,(byte)122,(byte)187,(byte)238,(byte)142,(byte)149,(byte)238,(byte)55,(byte)251,(byte)212,(byte)128,(byte)160,(byte)194,(byte)104,(byte)113,(byte)255,(byte)141,(byte)62,(byte)43,(byte)69,(byte)245,(byte)39,(byte)100,(byte)230,(byte)108,(byte)56,(byte)247,(byte)68,(byte)149,(byte)143,(byte)137,(byte)101,(byte)233,(byte)70,(byte)49,(byte)165,(byte)38,(byte)110,(byte)218,(byte)230,(byte)80,(byte)213,(byte)196,(byte)179,(byte)139,(byte)128,(byte)15,(byte)178,(byte)196,(byte)171,(byte)8,(byte)212,(byte)97,(byte)194,(byte)83,(byte)233,(byte)79,(byte)99,(byte)55,(byte)90,(byte)31,(byte)180,(byte)5,(byte)25,(byte)105,(byte)186,(byte)22,(byte)224,(byte)80,(byte)111,(byte)8,(byte)48,(byte)106,(byte)166,(byte)4,(byte)48,(byte)156,(byte)49,(byte)86,(byte)19,(byte)142,(byte)146,(byte)91,(byte)124,(byte)115,(byte)64,(byte)28,(byte)230,(byte)115,(byte)178,(byte)190,(byte)131,(byte)16,(byte)242,(byte)105,(byte)59,(byte)182,(byte)113,(byte)192,(byte)180,(byte)48,(byte)179,(byte)166,(byte)31,(byte)172,(byte)211,(byte)77,(byte)228,(byte)140,(byte)49,(byte)128,(byte)77,(byte)240,(byte)194,(byte)134,(byte)194,(byte)41,(byte)58,(byte)18,(byte)53,(byte)129,(byte)55,(byte)91,(byte)72,(byte)134,(byte)92,(byte)33,(byte)224,(byte)157,(byte)56,(byte)186,(byte)54,(byte)224,(byte)174,(byte)82,(byte)84,(byte)148,(byte)190,(byte)236,(byte)54,(byte)62,(byte)67,(byte)52,(byte)215,(byte)57,(byte)254,(byte)16,(byte)133,(byte)36,(byte)174,(byte)219,(byte)172,(byte)145,(byte)17,(byte)192,(byte)179,(byte)111,(byte)97,(byte)207,(byte)56,(byte)208,(byte)134,(byte)180,(byte)17,(byte)43,(byte)226,(byte)255,(byte)182,(byte)140,(byte)113, }; + SBPMessage sbp = new SBPMessage( 0x8137, 0x41, payload ); + MsgTrackingState msg = new MsgTrackingState( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.states[0].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].cn0 + "' != '" + 102 + "'", - value.equals(BigInteger.valueOf(102L))); + org.junit.Assert.assertTrue("'" + msg.states[0].cn0 + "' != '" + 102 + "'", value.equals(BigInteger.valueOf( 102L ) ) ); } else { value = value.longValue(); expected = 102L; @@ -303,9 +52,7 @@ public void test1() throws Throwable { } value = msg.states[0].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].fcn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[0].fcn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -313,9 +60,7 @@ public void test1() throws Throwable { } value = msg.states[0].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.code + "' != '" + 184 + "'", - value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.code + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -323,9 +68,7 @@ public void test1() throws Throwable { } value = msg.states[0].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.sat + "' != '" + 117 + "'", - value.equals(BigInteger.valueOf(117L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.sat + "' != '" + 117 + "'", value.equals(BigInteger.valueOf( 117L ) ) ); } else { value = value.longValue(); expected = 117L; @@ -333,9 +76,7 @@ public void test1() throws Throwable { } value = msg.states[1].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].cn0 + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.states[1].cn0 + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -343,9 +84,7 @@ public void test1() throws Throwable { } value = msg.states[1].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].fcn + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.states[1].fcn + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -353,9 +92,7 @@ public void test1() throws Throwable { } value = msg.states[1].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.code + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.code + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -363,9 +100,7 @@ public void test1() throws Throwable { } value = msg.states[1].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.sat + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.sat + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -373,9 +108,7 @@ public void test1() throws Throwable { } value = msg.states[2].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].cn0 + "' != '" + 195 + "'", - value.equals(BigInteger.valueOf(195L))); + org.junit.Assert.assertTrue("'" + msg.states[2].cn0 + "' != '" + 195 + "'", value.equals(BigInteger.valueOf( 195L ) ) ); } else { value = value.longValue(); expected = 195L; @@ -383,9 +116,7 @@ public void test1() throws Throwable { } value = msg.states[2].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].fcn + "' != '" + 90 + "'", - value.equals(BigInteger.valueOf(90L))); + org.junit.Assert.assertTrue("'" + msg.states[2].fcn + "' != '" + 90 + "'", value.equals(BigInteger.valueOf( 90L ) ) ); } else { value = value.longValue(); expected = 90L; @@ -393,9 +124,7 @@ public void test1() throws Throwable { } value = msg.states[2].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.code + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.code + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -403,9 +132,7 @@ public void test1() throws Throwable { } value = msg.states[2].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.sat + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.sat + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -413,9 +140,7 @@ public void test1() throws Throwable { } value = msg.states[3].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].cn0 + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.states[3].cn0 + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -423,9 +148,7 @@ public void test1() throws Throwable { } value = msg.states[3].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].fcn + "' != '" + 75 + "'", - value.equals(BigInteger.valueOf(75L))); + org.junit.Assert.assertTrue("'" + msg.states[3].fcn + "' != '" + 75 + "'", value.equals(BigInteger.valueOf( 75L ) ) ); } else { value = value.longValue(); expected = 75L; @@ -433,9 +156,7 @@ public void test1() throws Throwable { } value = msg.states[3].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.code + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.code + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -443,9 +164,7 @@ public void test1() throws Throwable { } value = msg.states[3].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.sat + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.sat + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -453,9 +172,7 @@ public void test1() throws Throwable { } value = msg.states[4].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].cn0 + "' != '" + 163 + "'", - value.equals(BigInteger.valueOf(163L))); + org.junit.Assert.assertTrue("'" + msg.states[4].cn0 + "' != '" + 163 + "'", value.equals(BigInteger.valueOf( 163L ) ) ); } else { value = value.longValue(); expected = 163L; @@ -463,9 +180,7 @@ public void test1() throws Throwable { } value = msg.states[4].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].fcn + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.states[4].fcn + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -473,9 +188,7 @@ public void test1() throws Throwable { } value = msg.states[4].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.code + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.code + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -483,9 +196,7 @@ public void test1() throws Throwable { } value = msg.states[4].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.sat + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.sat + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -493,9 +204,7 @@ public void test1() throws Throwable { } value = msg.states[5].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].cn0 + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.states[5].cn0 + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -503,9 +212,7 @@ public void test1() throws Throwable { } value = msg.states[5].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].fcn + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.states[5].fcn + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -513,9 +220,7 @@ public void test1() throws Throwable { } value = msg.states[5].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.code + "' != '" + 46 + "'", - value.equals(BigInteger.valueOf(46L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.code + "' != '" + 46 + "'", value.equals(BigInteger.valueOf( 46L ) ) ); } else { value = value.longValue(); expected = 46L; @@ -523,9 +228,7 @@ public void test1() throws Throwable { } value = msg.states[5].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.sat + "' != '" + 32 + "'", - value.equals(BigInteger.valueOf(32L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.sat + "' != '" + 32 + "'", value.equals(BigInteger.valueOf( 32L ) ) ); } else { value = value.longValue(); expected = 32L; @@ -533,9 +236,7 @@ public void test1() throws Throwable { } value = msg.states[6].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].cn0 + "' != '" + 147 + "'", - value.equals(BigInteger.valueOf(147L))); + org.junit.Assert.assertTrue("'" + msg.states[6].cn0 + "' != '" + 147 + "'", value.equals(BigInteger.valueOf( 147L ) ) ); } else { value = value.longValue(); expected = 147L; @@ -543,9 +244,7 @@ public void test1() throws Throwable { } value = msg.states[6].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].fcn + "' != '" + 201 + "'", - value.equals(BigInteger.valueOf(201L))); + org.junit.Assert.assertTrue("'" + msg.states[6].fcn + "' != '" + 201 + "'", value.equals(BigInteger.valueOf( 201L ) ) ); } else { value = value.longValue(); expected = 201L; @@ -553,9 +252,7 @@ public void test1() throws Throwable { } value = msg.states[6].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.code + "' != '" + 60 + "'", - value.equals(BigInteger.valueOf(60L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.code + "' != '" + 60 + "'", value.equals(BigInteger.valueOf( 60L ) ) ); } else { value = value.longValue(); expected = 60L; @@ -563,9 +260,7 @@ public void test1() throws Throwable { } value = msg.states[6].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.sat + "' != '" + 153 + "'", - value.equals(BigInteger.valueOf(153L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.sat + "' != '" + 153 + "'", value.equals(BigInteger.valueOf( 153L ) ) ); } else { value = value.longValue(); expected = 153L; @@ -573,9 +268,7 @@ public void test1() throws Throwable { } value = msg.states[7].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].cn0 + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.states[7].cn0 + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -583,9 +276,7 @@ public void test1() throws Throwable { } value = msg.states[7].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].fcn + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.states[7].fcn + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -593,9 +284,7 @@ public void test1() throws Throwable { } value = msg.states[7].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.code + "' != '" + 29 + "'", - value.equals(BigInteger.valueOf(29L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.code + "' != '" + 29 + "'", value.equals(BigInteger.valueOf( 29L ) ) ); } else { value = value.longValue(); expected = 29L; @@ -603,9 +292,7 @@ public void test1() throws Throwable { } value = msg.states[7].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.sat + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.sat + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -613,9 +300,7 @@ public void test1() throws Throwable { } value = msg.states[8].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].cn0 + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.states[8].cn0 + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -623,9 +308,7 @@ public void test1() throws Throwable { } value = msg.states[8].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].fcn + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.states[8].fcn + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -633,9 +316,7 @@ public void test1() throws Throwable { } value = msg.states[8].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.code + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.code + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -643,9 +324,7 @@ public void test1() throws Throwable { } value = msg.states[8].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.sat + "' != '" + 181 + "'", - value.equals(BigInteger.valueOf(181L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.sat + "' != '" + 181 + "'", value.equals(BigInteger.valueOf( 181L ) ) ); } else { value = value.longValue(); expected = 181L; @@ -653,9 +332,7 @@ public void test1() throws Throwable { } value = msg.states[9].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].cn0 + "' != '" + 121 + "'", - value.equals(BigInteger.valueOf(121L))); + org.junit.Assert.assertTrue("'" + msg.states[9].cn0 + "' != '" + 121 + "'", value.equals(BigInteger.valueOf( 121L ) ) ); } else { value = value.longValue(); expected = 121L; @@ -663,9 +340,7 @@ public void test1() throws Throwable { } value = msg.states[9].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].fcn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[9].fcn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -673,9 +348,7 @@ public void test1() throws Throwable { } value = msg.states[9].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.code + "' != '" + 136 + "'", - value.equals(BigInteger.valueOf(136L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.code + "' != '" + 136 + "'", value.equals(BigInteger.valueOf( 136L ) ) ); } else { value = value.longValue(); expected = 136L; @@ -683,9 +356,7 @@ public void test1() throws Throwable { } value = msg.states[9].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.sat + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.sat + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -693,9 +364,7 @@ public void test1() throws Throwable { } value = msg.states[10].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].cn0 + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.states[10].cn0 + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -703,9 +372,7 @@ public void test1() throws Throwable { } value = msg.states[10].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].fcn + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.states[10].fcn + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -713,9 +380,7 @@ public void test1() throws Throwable { } value = msg.states[10].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.code + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.code + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -723,9 +388,7 @@ public void test1() throws Throwable { } value = msg.states[10].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.sat + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.sat + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -733,9 +396,7 @@ public void test1() throws Throwable { } value = msg.states[11].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[11].cn0 + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.states[11].cn0 + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -743,9 +404,7 @@ public void test1() throws Throwable { } value = msg.states[11].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[11].fcn + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.states[11].fcn + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -753,9 +412,7 @@ public void test1() throws Throwable { } value = msg.states[11].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[11].sid.code + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.states[11].sid.code + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -763,9 +420,7 @@ public void test1() throws Throwable { } value = msg.states[11].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[11].sid.sat + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.states[11].sid.sat + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -773,9 +428,7 @@ public void test1() throws Throwable { } value = msg.states[12].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[12].cn0 + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.states[12].cn0 + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -783,9 +436,7 @@ public void test1() throws Throwable { } value = msg.states[12].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[12].fcn + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.states[12].fcn + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -793,9 +444,7 @@ public void test1() throws Throwable { } value = msg.states[12].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[12].sid.code + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.states[12].sid.code + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -803,9 +452,7 @@ public void test1() throws Throwable { } value = msg.states[12].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[12].sid.sat + "' != '" + 169 + "'", - value.equals(BigInteger.valueOf(169L))); + org.junit.Assert.assertTrue("'" + msg.states[12].sid.sat + "' != '" + 169 + "'", value.equals(BigInteger.valueOf( 169L ) ) ); } else { value = value.longValue(); expected = 169L; @@ -813,9 +460,7 @@ public void test1() throws Throwable { } value = msg.states[13].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[13].cn0 + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.states[13].cn0 + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -823,9 +468,7 @@ public void test1() throws Throwable { } value = msg.states[13].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[13].fcn + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.states[13].fcn + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -833,9 +476,7 @@ public void test1() throws Throwable { } value = msg.states[13].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[13].sid.code + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.states[13].sid.code + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -843,9 +484,7 @@ public void test1() throws Throwable { } value = msg.states[13].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[13].sid.sat + "' != '" + 242 + "'", - value.equals(BigInteger.valueOf(242L))); + org.junit.Assert.assertTrue("'" + msg.states[13].sid.sat + "' != '" + 242 + "'", value.equals(BigInteger.valueOf( 242L ) ) ); } else { value = value.longValue(); expected = 242L; @@ -853,9 +492,7 @@ public void test1() throws Throwable { } value = msg.states[14].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[14].cn0 + "' != '" + 130 + "'", - value.equals(BigInteger.valueOf(130L))); + org.junit.Assert.assertTrue("'" + msg.states[14].cn0 + "' != '" + 130 + "'", value.equals(BigInteger.valueOf( 130L ) ) ); } else { value = value.longValue(); expected = 130L; @@ -863,9 +500,7 @@ public void test1() throws Throwable { } value = msg.states[14].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[14].fcn + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.states[14].fcn + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -873,9 +508,7 @@ public void test1() throws Throwable { } value = msg.states[14].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[14].sid.code + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.states[14].sid.code + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -883,9 +516,7 @@ public void test1() throws Throwable { } value = msg.states[14].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[14].sid.sat + "' != '" + 152 + "'", - value.equals(BigInteger.valueOf(152L))); + org.junit.Assert.assertTrue("'" + msg.states[14].sid.sat + "' != '" + 152 + "'", value.equals(BigInteger.valueOf( 152L ) ) ); } else { value = value.longValue(); expected = 152L; @@ -893,9 +524,7 @@ public void test1() throws Throwable { } value = msg.states[15].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[15].cn0 + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.states[15].cn0 + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -903,9 +532,7 @@ public void test1() throws Throwable { } value = msg.states[15].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[15].fcn + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.states[15].fcn + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -913,9 +540,7 @@ public void test1() throws Throwable { } value = msg.states[15].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[15].sid.code + "' != '" + 21 + "'", - value.equals(BigInteger.valueOf(21L))); + org.junit.Assert.assertTrue("'" + msg.states[15].sid.code + "' != '" + 21 + "'", value.equals(BigInteger.valueOf( 21L ) ) ); } else { value = value.longValue(); expected = 21L; @@ -923,9 +548,7 @@ public void test1() throws Throwable { } value = msg.states[15].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[15].sid.sat + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.states[15].sid.sat + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -933,9 +556,7 @@ public void test1() throws Throwable { } value = msg.states[16].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[16].cn0 + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.states[16].cn0 + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -943,9 +564,7 @@ public void test1() throws Throwable { } value = msg.states[16].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[16].fcn + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.states[16].fcn + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -953,9 +572,7 @@ public void test1() throws Throwable { } value = msg.states[16].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[16].sid.code + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.states[16].sid.code + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -963,9 +580,7 @@ public void test1() throws Throwable { } value = msg.states[16].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[16].sid.sat + "' != '" + 253 + "'", - value.equals(BigInteger.valueOf(253L))); + org.junit.Assert.assertTrue("'" + msg.states[16].sid.sat + "' != '" + 253 + "'", value.equals(BigInteger.valueOf( 253L ) ) ); } else { value = value.longValue(); expected = 253L; @@ -973,9 +588,7 @@ public void test1() throws Throwable { } value = msg.states[17].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[17].cn0 + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.states[17].cn0 + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -983,9 +596,7 @@ public void test1() throws Throwable { } value = msg.states[17].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[17].fcn + "' != '" + 210 + "'", - value.equals(BigInteger.valueOf(210L))); + org.junit.Assert.assertTrue("'" + msg.states[17].fcn + "' != '" + 210 + "'", value.equals(BigInteger.valueOf( 210L ) ) ); } else { value = value.longValue(); expected = 210L; @@ -993,9 +604,7 @@ public void test1() throws Throwable { } value = msg.states[17].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[17].sid.code + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.states[17].sid.code + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -1003,9 +612,7 @@ public void test1() throws Throwable { } value = msg.states[17].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[17].sid.sat + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.states[17].sid.sat + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -1013,9 +620,7 @@ public void test1() throws Throwable { } value = msg.states[18].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[18].cn0 + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.states[18].cn0 + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -1023,9 +628,7 @@ public void test1() throws Throwable { } value = msg.states[18].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[18].fcn + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.states[18].fcn + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1033,9 +636,7 @@ public void test1() throws Throwable { } value = msg.states[18].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[18].sid.code + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.states[18].sid.code + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -1043,9 +644,7 @@ public void test1() throws Throwable { } value = msg.states[18].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[18].sid.sat + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.states[18].sid.sat + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -1053,9 +652,7 @@ public void test1() throws Throwable { } value = msg.states[19].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[19].cn0 + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.states[19].cn0 + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -1063,9 +660,7 @@ public void test1() throws Throwable { } value = msg.states[19].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[19].fcn + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.states[19].fcn + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -1073,9 +668,7 @@ public void test1() throws Throwable { } value = msg.states[19].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[19].sid.code + "' != '" + 75 + "'", - value.equals(BigInteger.valueOf(75L))); + org.junit.Assert.assertTrue("'" + msg.states[19].sid.code + "' != '" + 75 + "'", value.equals(BigInteger.valueOf( 75L ) ) ); } else { value = value.longValue(); expected = 75L; @@ -1083,9 +676,7 @@ public void test1() throws Throwable { } value = msg.states[19].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[19].sid.sat + "' != '" + 122 + "'", - value.equals(BigInteger.valueOf(122L))); + org.junit.Assert.assertTrue("'" + msg.states[19].sid.sat + "' != '" + 122 + "'", value.equals(BigInteger.valueOf( 122L ) ) ); } else { value = value.longValue(); expected = 122L; @@ -1093,9 +684,7 @@ public void test1() throws Throwable { } value = msg.states[20].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[20].cn0 + "' != '" + 122 + "'", - value.equals(BigInteger.valueOf(122L))); + org.junit.Assert.assertTrue("'" + msg.states[20].cn0 + "' != '" + 122 + "'", value.equals(BigInteger.valueOf( 122L ) ) ); } else { value = value.longValue(); expected = 122L; @@ -1103,9 +692,7 @@ public void test1() throws Throwable { } value = msg.states[20].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[20].fcn + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.states[20].fcn + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -1113,9 +700,7 @@ public void test1() throws Throwable { } value = msg.states[20].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[20].sid.code + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.states[20].sid.code + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -1123,9 +708,7 @@ public void test1() throws Throwable { } value = msg.states[20].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[20].sid.sat + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.states[20].sid.sat + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -1133,9 +716,7 @@ public void test1() throws Throwable { } value = msg.states[21].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[21].cn0 + "' != '" + 149 + "'", - value.equals(BigInteger.valueOf(149L))); + org.junit.Assert.assertTrue("'" + msg.states[21].cn0 + "' != '" + 149 + "'", value.equals(BigInteger.valueOf( 149L ) ) ); } else { value = value.longValue(); expected = 149L; @@ -1143,9 +724,7 @@ public void test1() throws Throwable { } value = msg.states[21].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[21].fcn + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.states[21].fcn + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -1153,9 +732,7 @@ public void test1() throws Throwable { } value = msg.states[21].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[21].sid.code + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.states[21].sid.code + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -1163,9 +740,7 @@ public void test1() throws Throwable { } value = msg.states[21].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[21].sid.sat + "' != '" + 187 + "'", - value.equals(BigInteger.valueOf(187L))); + org.junit.Assert.assertTrue("'" + msg.states[21].sid.sat + "' != '" + 187 + "'", value.equals(BigInteger.valueOf( 187L ) ) ); } else { value = value.longValue(); expected = 187L; @@ -1173,9 +748,7 @@ public void test1() throws Throwable { } value = msg.states[22].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[22].cn0 + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.states[22].cn0 + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -1183,9 +756,7 @@ public void test1() throws Throwable { } value = msg.states[22].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[22].fcn + "' != '" + 251 + "'", - value.equals(BigInteger.valueOf(251L))); + org.junit.Assert.assertTrue("'" + msg.states[22].fcn + "' != '" + 251 + "'", value.equals(BigInteger.valueOf( 251L ) ) ); } else { value = value.longValue(); expected = 251L; @@ -1193,9 +764,7 @@ public void test1() throws Throwable { } value = msg.states[22].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[22].sid.code + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.states[22].sid.code + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -1203,9 +772,7 @@ public void test1() throws Throwable { } value = msg.states[22].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[22].sid.sat + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.states[22].sid.sat + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -1213,9 +780,7 @@ public void test1() throws Throwable { } value = msg.states[23].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[23].cn0 + "' != '" + 104 + "'", - value.equals(BigInteger.valueOf(104L))); + org.junit.Assert.assertTrue("'" + msg.states[23].cn0 + "' != '" + 104 + "'", value.equals(BigInteger.valueOf( 104L ) ) ); } else { value = value.longValue(); expected = 104L; @@ -1223,9 +788,7 @@ public void test1() throws Throwable { } value = msg.states[23].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[23].fcn + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.states[23].fcn + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -1233,9 +796,7 @@ public void test1() throws Throwable { } value = msg.states[23].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[23].sid.code + "' != '" + 160 + "'", - value.equals(BigInteger.valueOf(160L))); + org.junit.Assert.assertTrue("'" + msg.states[23].sid.code + "' != '" + 160 + "'", value.equals(BigInteger.valueOf( 160L ) ) ); } else { value = value.longValue(); expected = 160L; @@ -1243,9 +804,7 @@ public void test1() throws Throwable { } value = msg.states[23].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[23].sid.sat + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.states[23].sid.sat + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -1253,9 +812,7 @@ public void test1() throws Throwable { } value = msg.states[24].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[24].cn0 + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.states[24].cn0 + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -1263,9 +820,7 @@ public void test1() throws Throwable { } value = msg.states[24].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[24].fcn + "' != '" + 141 + "'", - value.equals(BigInteger.valueOf(141L))); + org.junit.Assert.assertTrue("'" + msg.states[24].fcn + "' != '" + 141 + "'", value.equals(BigInteger.valueOf( 141L ) ) ); } else { value = value.longValue(); expected = 141L; @@ -1273,9 +828,7 @@ public void test1() throws Throwable { } value = msg.states[24].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[24].sid.code + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.states[24].sid.code + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -1283,9 +836,7 @@ public void test1() throws Throwable { } value = msg.states[24].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[24].sid.sat + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.states[24].sid.sat + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -1293,9 +844,7 @@ public void test1() throws Throwable { } value = msg.states[25].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[25].cn0 + "' != '" + 39 + "'", - value.equals(BigInteger.valueOf(39L))); + org.junit.Assert.assertTrue("'" + msg.states[25].cn0 + "' != '" + 39 + "'", value.equals(BigInteger.valueOf( 39L ) ) ); } else { value = value.longValue(); expected = 39L; @@ -1303,9 +852,7 @@ public void test1() throws Throwable { } value = msg.states[25].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[25].fcn + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.states[25].fcn + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -1313,9 +860,7 @@ public void test1() throws Throwable { } value = msg.states[25].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[25].sid.code + "' != '" + 69 + "'", - value.equals(BigInteger.valueOf(69L))); + org.junit.Assert.assertTrue("'" + msg.states[25].sid.code + "' != '" + 69 + "'", value.equals(BigInteger.valueOf( 69L ) ) ); } else { value = value.longValue(); expected = 69L; @@ -1323,9 +868,7 @@ public void test1() throws Throwable { } value = msg.states[25].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[25].sid.sat + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.states[25].sid.sat + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -1333,9 +876,7 @@ public void test1() throws Throwable { } value = msg.states[26].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[26].cn0 + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.states[26].cn0 + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -1343,9 +884,7 @@ public void test1() throws Throwable { } value = msg.states[26].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[26].fcn + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.states[26].fcn + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -1353,9 +892,7 @@ public void test1() throws Throwable { } value = msg.states[26].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[26].sid.code + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.states[26].sid.code + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1363,9 +900,7 @@ public void test1() throws Throwable { } value = msg.states[26].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[26].sid.sat + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.states[26].sid.sat + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -1373,9 +908,7 @@ public void test1() throws Throwable { } value = msg.states[27].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[27].cn0 + "' != '" + 143 + "'", - value.equals(BigInteger.valueOf(143L))); + org.junit.Assert.assertTrue("'" + msg.states[27].cn0 + "' != '" + 143 + "'", value.equals(BigInteger.valueOf( 143L ) ) ); } else { value = value.longValue(); expected = 143L; @@ -1383,9 +916,7 @@ public void test1() throws Throwable { } value = msg.states[27].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[27].fcn + "' != '" + 149 + "'", - value.equals(BigInteger.valueOf(149L))); + org.junit.Assert.assertTrue("'" + msg.states[27].fcn + "' != '" + 149 + "'", value.equals(BigInteger.valueOf( 149L ) ) ); } else { value = value.longValue(); expected = 149L; @@ -1393,9 +924,7 @@ public void test1() throws Throwable { } value = msg.states[27].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[27].sid.code + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.states[27].sid.code + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -1403,9 +932,7 @@ public void test1() throws Throwable { } value = msg.states[27].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[27].sid.sat + "' != '" + 247 + "'", - value.equals(BigInteger.valueOf(247L))); + org.junit.Assert.assertTrue("'" + msg.states[27].sid.sat + "' != '" + 247 + "'", value.equals(BigInteger.valueOf( 247L ) ) ); } else { value = value.longValue(); expected = 247L; @@ -1413,9 +940,7 @@ public void test1() throws Throwable { } value = msg.states[28].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[28].cn0 + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.states[28].cn0 + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -1423,9 +948,7 @@ public void test1() throws Throwable { } value = msg.states[28].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[28].fcn + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.states[28].fcn + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -1433,9 +956,7 @@ public void test1() throws Throwable { } value = msg.states[28].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[28].sid.code + "' != '" + 101 + "'", - value.equals(BigInteger.valueOf(101L))); + org.junit.Assert.assertTrue("'" + msg.states[28].sid.code + "' != '" + 101 + "'", value.equals(BigInteger.valueOf( 101L ) ) ); } else { value = value.longValue(); expected = 101L; @@ -1443,9 +964,7 @@ public void test1() throws Throwable { } value = msg.states[28].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[28].sid.sat + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.states[28].sid.sat + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -1453,9 +972,7 @@ public void test1() throws Throwable { } value = msg.states[29].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[29].cn0 + "' != '" + 110 + "'", - value.equals(BigInteger.valueOf(110L))); + org.junit.Assert.assertTrue("'" + msg.states[29].cn0 + "' != '" + 110 + "'", value.equals(BigInteger.valueOf( 110L ) ) ); } else { value = value.longValue(); expected = 110L; @@ -1463,9 +980,7 @@ public void test1() throws Throwable { } value = msg.states[29].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[29].fcn + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.states[29].fcn + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -1473,9 +988,7 @@ public void test1() throws Throwable { } value = msg.states[29].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[29].sid.code + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.states[29].sid.code + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -1483,9 +996,7 @@ public void test1() throws Throwable { } value = msg.states[29].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[29].sid.sat + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.states[29].sid.sat + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -1493,9 +1004,7 @@ public void test1() throws Throwable { } value = msg.states[30].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[30].cn0 + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.states[30].cn0 + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -1503,9 +1012,7 @@ public void test1() throws Throwable { } value = msg.states[30].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[30].fcn + "' != '" + 80 + "'", - value.equals(BigInteger.valueOf(80L))); + org.junit.Assert.assertTrue("'" + msg.states[30].fcn + "' != '" + 80 + "'", value.equals(BigInteger.valueOf( 80L ) ) ); } else { value = value.longValue(); expected = 80L; @@ -1513,9 +1020,7 @@ public void test1() throws Throwable { } value = msg.states[30].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[30].sid.code + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.states[30].sid.code + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -1523,9 +1028,7 @@ public void test1() throws Throwable { } value = msg.states[30].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[30].sid.sat + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.states[30].sid.sat + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -1533,9 +1036,7 @@ public void test1() throws Throwable { } value = msg.states[31].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[31].cn0 + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.states[31].cn0 + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -1543,9 +1044,7 @@ public void test1() throws Throwable { } value = msg.states[31].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[31].fcn + "' != '" + 139 + "'", - value.equals(BigInteger.valueOf(139L))); + org.junit.Assert.assertTrue("'" + msg.states[31].fcn + "' != '" + 139 + "'", value.equals(BigInteger.valueOf( 139L ) ) ); } else { value = value.longValue(); expected = 139L; @@ -1553,9 +1052,7 @@ public void test1() throws Throwable { } value = msg.states[31].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[31].sid.code + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.states[31].sid.code + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -1563,9 +1060,7 @@ public void test1() throws Throwable { } value = msg.states[31].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[31].sid.sat + "' != '" + 196 + "'", - value.equals(BigInteger.valueOf(196L))); + org.junit.Assert.assertTrue("'" + msg.states[31].sid.sat + "' != '" + 196 + "'", value.equals(BigInteger.valueOf( 196L ) ) ); } else { value = value.longValue(); expected = 196L; @@ -1573,9 +1068,7 @@ public void test1() throws Throwable { } value = msg.states[32].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[32].cn0 + "' != '" + 171 + "'", - value.equals(BigInteger.valueOf(171L))); + org.junit.Assert.assertTrue("'" + msg.states[32].cn0 + "' != '" + 171 + "'", value.equals(BigInteger.valueOf( 171L ) ) ); } else { value = value.longValue(); expected = 171L; @@ -1583,9 +1076,7 @@ public void test1() throws Throwable { } value = msg.states[32].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[32].fcn + "' != '" + 196 + "'", - value.equals(BigInteger.valueOf(196L))); + org.junit.Assert.assertTrue("'" + msg.states[32].fcn + "' != '" + 196 + "'", value.equals(BigInteger.valueOf( 196L ) ) ); } else { value = value.longValue(); expected = 196L; @@ -1593,9 +1084,7 @@ public void test1() throws Throwable { } value = msg.states[32].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[32].sid.code + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.states[32].sid.code + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -1603,9 +1092,7 @@ public void test1() throws Throwable { } value = msg.states[32].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[32].sid.sat + "' != '" + 15 + "'", - value.equals(BigInteger.valueOf(15L))); + org.junit.Assert.assertTrue("'" + msg.states[32].sid.sat + "' != '" + 15 + "'", value.equals(BigInteger.valueOf( 15L ) ) ); } else { value = value.longValue(); expected = 15L; @@ -1613,9 +1100,7 @@ public void test1() throws Throwable { } value = msg.states[33].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[33].cn0 + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.states[33].cn0 + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -1623,9 +1108,7 @@ public void test1() throws Throwable { } value = msg.states[33].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[33].fcn + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.states[33].fcn + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -1633,9 +1116,7 @@ public void test1() throws Throwable { } value = msg.states[33].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[33].sid.code + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.states[33].sid.code + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -1643,9 +1124,7 @@ public void test1() throws Throwable { } value = msg.states[33].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[33].sid.sat + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.states[33].sid.sat + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -1653,9 +1132,7 @@ public void test1() throws Throwable { } value = msg.states[34].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[34].cn0 + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.states[34].cn0 + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -1663,9 +1140,7 @@ public void test1() throws Throwable { } value = msg.states[34].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[34].fcn + "' != '" + 79 + "'", - value.equals(BigInteger.valueOf(79L))); + org.junit.Assert.assertTrue("'" + msg.states[34].fcn + "' != '" + 79 + "'", value.equals(BigInteger.valueOf( 79L ) ) ); } else { value = value.longValue(); expected = 79L; @@ -1673,9 +1148,7 @@ public void test1() throws Throwable { } value = msg.states[34].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[34].sid.code + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.states[34].sid.code + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -1683,9 +1156,7 @@ public void test1() throws Throwable { } value = msg.states[34].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[34].sid.sat + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.states[34].sid.sat + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -1693,9 +1164,7 @@ public void test1() throws Throwable { } value = msg.states[35].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[35].cn0 + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.states[35].cn0 + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -1703,9 +1172,7 @@ public void test1() throws Throwable { } value = msg.states[35].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[35].fcn + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.states[35].fcn + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -1713,9 +1180,7 @@ public void test1() throws Throwable { } value = msg.states[35].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[35].sid.code + "' != '" + 90 + "'", - value.equals(BigInteger.valueOf(90L))); + org.junit.Assert.assertTrue("'" + msg.states[35].sid.code + "' != '" + 90 + "'", value.equals(BigInteger.valueOf( 90L ) ) ); } else { value = value.longValue(); expected = 90L; @@ -1723,9 +1188,7 @@ public void test1() throws Throwable { } value = msg.states[35].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[35].sid.sat + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.states[35].sid.sat + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -1733,9 +1196,7 @@ public void test1() throws Throwable { } value = msg.states[36].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[36].cn0 + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.states[36].cn0 + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -1743,9 +1204,7 @@ public void test1() throws Throwable { } value = msg.states[36].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[36].fcn + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.states[36].fcn + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -1753,9 +1212,7 @@ public void test1() throws Throwable { } value = msg.states[36].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[36].sid.code + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.states[36].sid.code + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -1763,9 +1220,7 @@ public void test1() throws Throwable { } value = msg.states[36].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[36].sid.sat + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.states[36].sid.sat + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -1773,9 +1228,7 @@ public void test1() throws Throwable { } value = msg.states[37].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[37].cn0 + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.states[37].cn0 + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -1783,9 +1236,7 @@ public void test1() throws Throwable { } value = msg.states[37].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[37].fcn + "' != '" + 80 + "'", - value.equals(BigInteger.valueOf(80L))); + org.junit.Assert.assertTrue("'" + msg.states[37].fcn + "' != '" + 80 + "'", value.equals(BigInteger.valueOf( 80L ) ) ); } else { value = value.longValue(); expected = 80L; @@ -1793,9 +1244,7 @@ public void test1() throws Throwable { } value = msg.states[37].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[37].sid.code + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.states[37].sid.code + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -1803,9 +1252,7 @@ public void test1() throws Throwable { } value = msg.states[37].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[37].sid.sat + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.states[37].sid.sat + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -1813,9 +1260,7 @@ public void test1() throws Throwable { } value = msg.states[38].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[38].cn0 + "' != '" + 166 + "'", - value.equals(BigInteger.valueOf(166L))); + org.junit.Assert.assertTrue("'" + msg.states[38].cn0 + "' != '" + 166 + "'", value.equals(BigInteger.valueOf( 166L ) ) ); } else { value = value.longValue(); expected = 166L; @@ -1823,9 +1268,7 @@ public void test1() throws Throwable { } value = msg.states[38].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[38].fcn + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.states[38].fcn + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -1833,9 +1276,7 @@ public void test1() throws Throwable { } value = msg.states[38].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[38].sid.code + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.states[38].sid.code + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -1843,9 +1284,7 @@ public void test1() throws Throwable { } value = msg.states[38].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[38].sid.sat + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.states[38].sid.sat + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -1853,9 +1292,7 @@ public void test1() throws Throwable { } value = msg.states[39].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[39].cn0 + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.states[39].cn0 + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -1863,9 +1300,7 @@ public void test1() throws Throwable { } value = msg.states[39].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[39].fcn + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.states[39].fcn + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -1873,9 +1308,7 @@ public void test1() throws Throwable { } value = msg.states[39].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[39].sid.code + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.states[39].sid.code + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -1883,9 +1316,7 @@ public void test1() throws Throwable { } value = msg.states[39].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[39].sid.sat + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.states[39].sid.sat + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1893,9 +1324,7 @@ public void test1() throws Throwable { } value = msg.states[40].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[40].cn0 + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.states[40].cn0 + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -1903,9 +1332,7 @@ public void test1() throws Throwable { } value = msg.states[40].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[40].fcn + "' != '" + 142 + "'", - value.equals(BigInteger.valueOf(142L))); + org.junit.Assert.assertTrue("'" + msg.states[40].fcn + "' != '" + 142 + "'", value.equals(BigInteger.valueOf( 142L ) ) ); } else { value = value.longValue(); expected = 142L; @@ -1913,9 +1340,7 @@ public void test1() throws Throwable { } value = msg.states[40].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[40].sid.code + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.states[40].sid.code + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -1923,9 +1348,7 @@ public void test1() throws Throwable { } value = msg.states[40].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[40].sid.sat + "' != '" + 86 + "'", - value.equals(BigInteger.valueOf(86L))); + org.junit.Assert.assertTrue("'" + msg.states[40].sid.sat + "' != '" + 86 + "'", value.equals(BigInteger.valueOf( 86L ) ) ); } else { value = value.longValue(); expected = 86L; @@ -1933,9 +1356,7 @@ public void test1() throws Throwable { } value = msg.states[41].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[41].cn0 + "' != '" + 64 + "'", - value.equals(BigInteger.valueOf(64L))); + org.junit.Assert.assertTrue("'" + msg.states[41].cn0 + "' != '" + 64 + "'", value.equals(BigInteger.valueOf( 64L ) ) ); } else { value = value.longValue(); expected = 64L; @@ -1943,9 +1364,7 @@ public void test1() throws Throwable { } value = msg.states[41].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[41].fcn + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.states[41].fcn + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1953,9 +1372,7 @@ public void test1() throws Throwable { } value = msg.states[41].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[41].sid.code + "' != '" + 124 + "'", - value.equals(BigInteger.valueOf(124L))); + org.junit.Assert.assertTrue("'" + msg.states[41].sid.code + "' != '" + 124 + "'", value.equals(BigInteger.valueOf( 124L ) ) ); } else { value = value.longValue(); expected = 124L; @@ -1963,9 +1380,7 @@ public void test1() throws Throwable { } value = msg.states[41].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[41].sid.sat + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.states[41].sid.sat + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -1973,9 +1388,7 @@ public void test1() throws Throwable { } value = msg.states[42].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[42].cn0 + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.states[42].cn0 + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -1983,9 +1396,7 @@ public void test1() throws Throwable { } value = msg.states[42].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[42].fcn + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.states[42].fcn + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -1993,9 +1404,7 @@ public void test1() throws Throwable { } value = msg.states[42].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[42].sid.code + "' != '" + 230 + "'", - value.equals(BigInteger.valueOf(230L))); + org.junit.Assert.assertTrue("'" + msg.states[42].sid.code + "' != '" + 230 + "'", value.equals(BigInteger.valueOf( 230L ) ) ); } else { value = value.longValue(); expected = 230L; @@ -2003,9 +1412,7 @@ public void test1() throws Throwable { } value = msg.states[42].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[42].sid.sat + "' != '" + 28 + "'", - value.equals(BigInteger.valueOf(28L))); + org.junit.Assert.assertTrue("'" + msg.states[42].sid.sat + "' != '" + 28 + "'", value.equals(BigInteger.valueOf( 28L ) ) ); } else { value = value.longValue(); expected = 28L; @@ -2013,9 +1420,7 @@ public void test1() throws Throwable { } value = msg.states[43].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[43].cn0 + "' != '" + 242 + "'", - value.equals(BigInteger.valueOf(242L))); + org.junit.Assert.assertTrue("'" + msg.states[43].cn0 + "' != '" + 242 + "'", value.equals(BigInteger.valueOf( 242L ) ) ); } else { value = value.longValue(); expected = 242L; @@ -2023,9 +1428,7 @@ public void test1() throws Throwable { } value = msg.states[43].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[43].fcn + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.states[43].fcn + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -2033,9 +1436,7 @@ public void test1() throws Throwable { } value = msg.states[43].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[43].sid.code + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.states[43].sid.code + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -2043,9 +1444,7 @@ public void test1() throws Throwable { } value = msg.states[43].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[43].sid.sat + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.states[43].sid.sat + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -2053,9 +1452,7 @@ public void test1() throws Throwable { } value = msg.states[44].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[44].cn0 + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.states[44].cn0 + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -2063,9 +1460,7 @@ public void test1() throws Throwable { } value = msg.states[44].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[44].fcn + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.states[44].fcn + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -2073,9 +1468,7 @@ public void test1() throws Throwable { } value = msg.states[44].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[44].sid.code + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.states[44].sid.code + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -2083,9 +1476,7 @@ public void test1() throws Throwable { } value = msg.states[44].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[44].sid.sat + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.states[44].sid.sat + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -2093,9 +1484,7 @@ public void test1() throws Throwable { } value = msg.states[45].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[45].cn0 + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.states[45].cn0 + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -2103,9 +1492,7 @@ public void test1() throws Throwable { } value = msg.states[45].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[45].fcn + "' != '" + 48 + "'", - value.equals(BigInteger.valueOf(48L))); + org.junit.Assert.assertTrue("'" + msg.states[45].fcn + "' != '" + 48 + "'", value.equals(BigInteger.valueOf( 48L ) ) ); } else { value = value.longValue(); expected = 48L; @@ -2113,9 +1500,7 @@ public void test1() throws Throwable { } value = msg.states[45].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[45].sid.code + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.states[45].sid.code + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -2123,9 +1508,7 @@ public void test1() throws Throwable { } value = msg.states[45].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[45].sid.sat + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.states[45].sid.sat + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -2133,9 +1516,7 @@ public void test1() throws Throwable { } value = msg.states[46].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[46].cn0 + "' != '" + 211 + "'", - value.equals(BigInteger.valueOf(211L))); + org.junit.Assert.assertTrue("'" + msg.states[46].cn0 + "' != '" + 211 + "'", value.equals(BigInteger.valueOf( 211L ) ) ); } else { value = value.longValue(); expected = 211L; @@ -2143,9 +1524,7 @@ public void test1() throws Throwable { } value = msg.states[46].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[46].fcn + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.states[46].fcn + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -2153,9 +1532,7 @@ public void test1() throws Throwable { } value = msg.states[46].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[46].sid.code + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.states[46].sid.code + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -2163,9 +1540,7 @@ public void test1() throws Throwable { } value = msg.states[46].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[46].sid.sat + "' != '" + 166 + "'", - value.equals(BigInteger.valueOf(166L))); + org.junit.Assert.assertTrue("'" + msg.states[46].sid.sat + "' != '" + 166 + "'", value.equals(BigInteger.valueOf( 166L ) ) ); } else { value = value.longValue(); expected = 166L; @@ -2173,9 +1548,7 @@ public void test1() throws Throwable { } value = msg.states[47].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[47].cn0 + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.states[47].cn0 + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -2183,9 +1556,7 @@ public void test1() throws Throwable { } value = msg.states[47].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[47].fcn + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.states[47].fcn + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -2193,9 +1564,7 @@ public void test1() throws Throwable { } value = msg.states[47].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[47].sid.code + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.states[47].sid.code + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -2203,9 +1572,7 @@ public void test1() throws Throwable { } value = msg.states[47].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[47].sid.sat + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.states[47].sid.sat + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -2213,9 +1580,7 @@ public void test1() throws Throwable { } value = msg.states[48].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[48].cn0 + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.states[48].cn0 + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -2223,9 +1588,7 @@ public void test1() throws Throwable { } value = msg.states[48].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[48].fcn + "' != '" + 240 + "'", - value.equals(BigInteger.valueOf(240L))); + org.junit.Assert.assertTrue("'" + msg.states[48].fcn + "' != '" + 240 + "'", value.equals(BigInteger.valueOf( 240L ) ) ); } else { value = value.longValue(); expected = 240L; @@ -2233,9 +1596,7 @@ public void test1() throws Throwable { } value = msg.states[48].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[48].sid.code + "' != '" + 77 + "'", - value.equals(BigInteger.valueOf(77L))); + org.junit.Assert.assertTrue("'" + msg.states[48].sid.code + "' != '" + 77 + "'", value.equals(BigInteger.valueOf( 77L ) ) ); } else { value = value.longValue(); expected = 77L; @@ -2243,9 +1604,7 @@ public void test1() throws Throwable { } value = msg.states[48].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[48].sid.sat + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.states[48].sid.sat + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -2253,9 +1612,7 @@ public void test1() throws Throwable { } value = msg.states[49].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[49].cn0 + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.states[49].cn0 + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -2263,9 +1620,7 @@ public void test1() throws Throwable { } value = msg.states[49].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[49].fcn + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.states[49].fcn + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -2273,9 +1628,7 @@ public void test1() throws Throwable { } value = msg.states[49].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[49].sid.code + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.states[49].sid.code + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -2283,9 +1636,7 @@ public void test1() throws Throwable { } value = msg.states[49].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[49].sid.sat + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.states[49].sid.sat + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -2293,9 +1644,7 @@ public void test1() throws Throwable { } value = msg.states[50].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[50].cn0 + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.states[50].cn0 + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -2303,9 +1652,7 @@ public void test1() throws Throwable { } value = msg.states[50].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[50].fcn + "' != '" + 129 + "'", - value.equals(BigInteger.valueOf(129L))); + org.junit.Assert.assertTrue("'" + msg.states[50].fcn + "' != '" + 129 + "'", value.equals(BigInteger.valueOf( 129L ) ) ); } else { value = value.longValue(); expected = 129L; @@ -2313,9 +1660,7 @@ public void test1() throws Throwable { } value = msg.states[50].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[50].sid.code + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.states[50].sid.code + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -2323,9 +1668,7 @@ public void test1() throws Throwable { } value = msg.states[50].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[50].sid.sat + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.states[50].sid.sat + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -2333,9 +1676,7 @@ public void test1() throws Throwable { } value = msg.states[51].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[51].cn0 + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.states[51].cn0 + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -2343,9 +1684,7 @@ public void test1() throws Throwable { } value = msg.states[51].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[51].fcn + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.states[51].fcn + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -2353,9 +1692,7 @@ public void test1() throws Throwable { } value = msg.states[51].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[51].sid.code + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.states[51].sid.code + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -2363,9 +1700,7 @@ public void test1() throws Throwable { } value = msg.states[51].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[51].sid.sat + "' != '" + 91 + "'", - value.equals(BigInteger.valueOf(91L))); + org.junit.Assert.assertTrue("'" + msg.states[51].sid.sat + "' != '" + 91 + "'", value.equals(BigInteger.valueOf( 91L ) ) ); } else { value = value.longValue(); expected = 91L; @@ -2373,9 +1708,7 @@ public void test1() throws Throwable { } value = msg.states[52].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[52].cn0 + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.states[52].cn0 + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -2383,9 +1716,7 @@ public void test1() throws Throwable { } value = msg.states[52].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[52].fcn + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.states[52].fcn + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -2393,9 +1724,7 @@ public void test1() throws Throwable { } value = msg.states[52].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[52].sid.code + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.states[52].sid.code + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -2403,9 +1732,7 @@ public void test1() throws Throwable { } value = msg.states[52].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[52].sid.sat + "' != '" + 33 + "'", - value.equals(BigInteger.valueOf(33L))); + org.junit.Assert.assertTrue("'" + msg.states[52].sid.sat + "' != '" + 33 + "'", value.equals(BigInteger.valueOf( 33L ) ) ); } else { value = value.longValue(); expected = 33L; @@ -2413,9 +1740,7 @@ public void test1() throws Throwable { } value = msg.states[53].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[53].cn0 + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.states[53].cn0 + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -2423,9 +1748,7 @@ public void test1() throws Throwable { } value = msg.states[53].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[53].fcn + "' != '" + 224 + "'", - value.equals(BigInteger.valueOf(224L))); + org.junit.Assert.assertTrue("'" + msg.states[53].fcn + "' != '" + 224 + "'", value.equals(BigInteger.valueOf( 224L ) ) ); } else { value = value.longValue(); expected = 224L; @@ -2433,9 +1756,7 @@ public void test1() throws Throwable { } value = msg.states[53].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[53].sid.code + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.states[53].sid.code + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -2443,9 +1764,7 @@ public void test1() throws Throwable { } value = msg.states[53].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[53].sid.sat + "' != '" + 186 + "'", - value.equals(BigInteger.valueOf(186L))); + org.junit.Assert.assertTrue("'" + msg.states[53].sid.sat + "' != '" + 186 + "'", value.equals(BigInteger.valueOf( 186L ) ) ); } else { value = value.longValue(); expected = 186L; @@ -2453,9 +1772,7 @@ public void test1() throws Throwable { } value = msg.states[54].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[54].cn0 + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.states[54].cn0 + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -2463,9 +1780,7 @@ public void test1() throws Throwable { } value = msg.states[54].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[54].fcn + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.states[54].fcn + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -2473,9 +1788,7 @@ public void test1() throws Throwable { } value = msg.states[54].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[54].sid.code + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.states[54].sid.code + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -2483,9 +1796,7 @@ public void test1() throws Throwable { } value = msg.states[54].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[54].sid.sat + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.states[54].sid.sat + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -2493,9 +1804,7 @@ public void test1() throws Throwable { } value = msg.states[55].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[55].cn0 + "' != '" + 67 + "'", - value.equals(BigInteger.valueOf(67L))); + org.junit.Assert.assertTrue("'" + msg.states[55].cn0 + "' != '" + 67 + "'", value.equals(BigInteger.valueOf( 67L ) ) ); } else { value = value.longValue(); expected = 67L; @@ -2503,9 +1812,7 @@ public void test1() throws Throwable { } value = msg.states[55].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[55].fcn + "' != '" + 62 + "'", - value.equals(BigInteger.valueOf(62L))); + org.junit.Assert.assertTrue("'" + msg.states[55].fcn + "' != '" + 62 + "'", value.equals(BigInteger.valueOf( 62L ) ) ); } else { value = value.longValue(); expected = 62L; @@ -2513,9 +1820,7 @@ public void test1() throws Throwable { } value = msg.states[55].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[55].sid.code + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.states[55].sid.code + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -2523,9 +1828,7 @@ public void test1() throws Throwable { } value = msg.states[55].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[55].sid.sat + "' != '" + 236 + "'", - value.equals(BigInteger.valueOf(236L))); + org.junit.Assert.assertTrue("'" + msg.states[55].sid.sat + "' != '" + 236 + "'", value.equals(BigInteger.valueOf( 236L ) ) ); } else { value = value.longValue(); expected = 236L; @@ -2533,9 +1836,7 @@ public void test1() throws Throwable { } value = msg.states[56].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[56].cn0 + "' != '" + 254 + "'", - value.equals(BigInteger.valueOf(254L))); + org.junit.Assert.assertTrue("'" + msg.states[56].cn0 + "' != '" + 254 + "'", value.equals(BigInteger.valueOf( 254L ) ) ); } else { value = value.longValue(); expected = 254L; @@ -2543,9 +1844,7 @@ public void test1() throws Throwable { } value = msg.states[56].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[56].fcn + "' != '" + 57 + "'", - value.equals(BigInteger.valueOf(57L))); + org.junit.Assert.assertTrue("'" + msg.states[56].fcn + "' != '" + 57 + "'", value.equals(BigInteger.valueOf( 57L ) ) ); } else { value = value.longValue(); expected = 57L; @@ -2553,9 +1852,7 @@ public void test1() throws Throwable { } value = msg.states[56].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[56].sid.code + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.states[56].sid.code + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -2563,9 +1860,7 @@ public void test1() throws Throwable { } value = msg.states[56].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[56].sid.sat + "' != '" + 52 + "'", - value.equals(BigInteger.valueOf(52L))); + org.junit.Assert.assertTrue("'" + msg.states[56].sid.sat + "' != '" + 52 + "'", value.equals(BigInteger.valueOf( 52L ) ) ); } else { value = value.longValue(); expected = 52L; @@ -2573,9 +1868,7 @@ public void test1() throws Throwable { } value = msg.states[57].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[57].cn0 + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.states[57].cn0 + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -2583,9 +1876,7 @@ public void test1() throws Throwable { } value = msg.states[57].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[57].fcn + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.states[57].fcn + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -2593,9 +1884,7 @@ public void test1() throws Throwable { } value = msg.states[57].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[57].sid.code + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.states[57].sid.code + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -2603,9 +1892,7 @@ public void test1() throws Throwable { } value = msg.states[57].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[57].sid.sat + "' != '" + 16 + "'", - value.equals(BigInteger.valueOf(16L))); + org.junit.Assert.assertTrue("'" + msg.states[57].sid.sat + "' != '" + 16 + "'", value.equals(BigInteger.valueOf( 16L ) ) ); } else { value = value.longValue(); expected = 16L; @@ -2613,9 +1900,7 @@ public void test1() throws Throwable { } value = msg.states[58].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[58].cn0 + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.states[58].cn0 + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -2623,9 +1908,7 @@ public void test1() throws Throwable { } value = msg.states[58].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[58].fcn + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.states[58].fcn + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -2633,9 +1916,7 @@ public void test1() throws Throwable { } value = msg.states[58].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[58].sid.code + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.states[58].sid.code + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -2643,9 +1924,7 @@ public void test1() throws Throwable { } value = msg.states[58].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[58].sid.sat + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.states[58].sid.sat + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -2653,9 +1932,7 @@ public void test1() throws Throwable { } value = msg.states[59].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[59].cn0 + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.states[59].cn0 + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -2663,9 +1940,7 @@ public void test1() throws Throwable { } value = msg.states[59].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[59].fcn + "' != '" + 111 + "'", - value.equals(BigInteger.valueOf(111L))); + org.junit.Assert.assertTrue("'" + msg.states[59].fcn + "' != '" + 111 + "'", value.equals(BigInteger.valueOf( 111L ) ) ); } else { value = value.longValue(); expected = 111L; @@ -2673,9 +1948,7 @@ public void test1() throws Throwable { } value = msg.states[59].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[59].sid.code + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.states[59].sid.code + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -2683,9 +1956,7 @@ public void test1() throws Throwable { } value = msg.states[59].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[59].sid.sat + "' != '" + 192 + "'", - value.equals(BigInteger.valueOf(192L))); + org.junit.Assert.assertTrue("'" + msg.states[59].sid.sat + "' != '" + 192 + "'", value.equals(BigInteger.valueOf( 192L ) ) ); } else { value = value.longValue(); expected = 192L; @@ -2693,9 +1964,7 @@ public void test1() throws Throwable { } value = msg.states[60].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[60].cn0 + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.states[60].cn0 + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -2703,9 +1972,7 @@ public void test1() throws Throwable { } value = msg.states[60].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[60].fcn + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.states[60].fcn + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -2713,9 +1980,7 @@ public void test1() throws Throwable { } value = msg.states[60].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[60].sid.code + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.states[60].sid.code + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -2723,9 +1988,7 @@ public void test1() throws Throwable { } value = msg.states[60].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[60].sid.sat + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.states[60].sid.sat + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -2733,9 +1996,7 @@ public void test1() throws Throwable { } value = msg.states[61].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[61].cn0 + "' != '" + 226 + "'", - value.equals(BigInteger.valueOf(226L))); + org.junit.Assert.assertTrue("'" + msg.states[61].cn0 + "' != '" + 226 + "'", value.equals(BigInteger.valueOf( 226L ) ) ); } else { value = value.longValue(); expected = 226L; @@ -2743,9 +2004,7 @@ public void test1() throws Throwable { } value = msg.states[61].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[61].fcn + "' != '" + 43 + "'", - value.equals(BigInteger.valueOf(43L))); + org.junit.Assert.assertTrue("'" + msg.states[61].fcn + "' != '" + 43 + "'", value.equals(BigInteger.valueOf( 43L ) ) ); } else { value = value.longValue(); expected = 43L; @@ -2753,9 +2012,7 @@ public void test1() throws Throwable { } value = msg.states[61].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[61].sid.code + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.states[61].sid.code + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -2763,9 +2020,7 @@ public void test1() throws Throwable { } value = msg.states[61].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[61].sid.sat + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.states[61].sid.sat + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -2773,9 +2028,7 @@ public void test1() throws Throwable { } value = msg.states[62].cn0; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[62].cn0 + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.states[62].cn0 + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -2783,9 +2036,7 @@ public void test1() throws Throwable { } value = msg.states[62].fcn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[62].fcn + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.states[62].fcn + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -2793,9 +2044,7 @@ public void test1() throws Throwable { } value = msg.states[62].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[62].sid.code + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.states[62].sid.code + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -2803,9 +2052,7 @@ public void test1() throws Throwable { } value = msg.states[62].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[62].sid.sat + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.states[62].sid.sat + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -2819,35 +2066,16 @@ public void test1() throws Throwable { public void test2() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateTest.test2"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 202, (byte) 0, (byte) 0, (byte) 0, (byte) 197, (byte) 253, - (byte) 28, (byte) 66, (byte) 1, (byte) 203, (byte) 0, (byte) 0, (byte) 0, - (byte) 231, (byte) 99, (byte) 16, (byte) 66, (byte) 1, (byte) 208, (byte) 0, - (byte) 0, (byte) 0, (byte) 212, (byte) 129, (byte) 22, (byte) 66, (byte) 1, - (byte) 212, (byte) 0, (byte) 0, (byte) 0, (byte) 58, (byte) 21, (byte) 28, - (byte) 66, (byte) 1, (byte) 217, (byte) 0, (byte) 0, (byte) 0, (byte) 178, - (byte) 33, (byte) 40, (byte) 66, (byte) 1, (byte) 218, (byte) 0, (byte) 0, - (byte) 0, (byte) 235, (byte) 189, (byte) 21, (byte) 66, (byte) 1, (byte) 220, - (byte) 0, (byte) 0, (byte) 0, (byte) 29, (byte) 177, (byte) 25, (byte) 66, - (byte) 1, (byte) 222, (byte) 0, (byte) 0, (byte) 0, (byte) 43, (byte) 169, - (byte) 27, (byte) 66, (byte) 1, (byte) 225, (byte) 0, (byte) 0, (byte) 0, - (byte) 137, (byte) 125, (byte) 42, (byte) 66, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, - (byte) 191, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x13, payload); - MsgTrackingStateDepB msg = new MsgTrackingStateDepB(sbp); + byte[] payload = new byte[] {(byte)1,(byte)202,(byte)0,(byte)0,(byte)0,(byte)197,(byte)253,(byte)28,(byte)66,(byte)1,(byte)203,(byte)0,(byte)0,(byte)0,(byte)231,(byte)99,(byte)16,(byte)66,(byte)1,(byte)208,(byte)0,(byte)0,(byte)0,(byte)212,(byte)129,(byte)22,(byte)66,(byte)1,(byte)212,(byte)0,(byte)0,(byte)0,(byte)58,(byte)21,(byte)28,(byte)66,(byte)1,(byte)217,(byte)0,(byte)0,(byte)0,(byte)178,(byte)33,(byte)40,(byte)66,(byte)1,(byte)218,(byte)0,(byte)0,(byte)0,(byte)235,(byte)189,(byte)21,(byte)66,(byte)1,(byte)220,(byte)0,(byte)0,(byte)0,(byte)29,(byte)177,(byte)25,(byte)66,(byte)1,(byte)222,(byte)0,(byte)0,(byte)0,(byte)43,(byte)169,(byte)27,(byte)66,(byte)1,(byte)225,(byte)0,(byte)0,(byte)0,(byte)137,(byte)125,(byte)42,(byte)66,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x13, payload ); + MsgTrackingStateDepB msg = new MsgTrackingStateDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.states[0].cn0, 3.92478218078613281e+01, DELTA); value = msg.states[0].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2855,9 +2083,7 @@ public void test2() throws Throwable { } value = msg.states[0].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2865,9 +2091,7 @@ public void test2() throws Throwable { } value = msg.states[0].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.sat + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.sat + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -2875,9 +2099,7 @@ public void test2() throws Throwable { } value = msg.states[0].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[0].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -2886,9 +2108,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[1].cn0, 3.60975608825683594e+01, DELTA); value = msg.states[1].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2896,9 +2116,7 @@ public void test2() throws Throwable { } value = msg.states[1].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2906,9 +2124,7 @@ public void test2() throws Throwable { } value = msg.states[1].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.sat + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.sat + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -2916,9 +2132,7 @@ public void test2() throws Throwable { } value = msg.states[1].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[1].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -2927,9 +2141,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[2].cn0, 3.76267852783203125e+01, DELTA); value = msg.states[2].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2937,9 +2149,7 @@ public void test2() throws Throwable { } value = msg.states[2].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2947,9 +2157,7 @@ public void test2() throws Throwable { } value = msg.states[2].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.sat + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.sat + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -2957,9 +2165,7 @@ public void test2() throws Throwable { } value = msg.states[2].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[2].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -2968,9 +2174,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[3].cn0, 3.90207290649414062e+01, DELTA); value = msg.states[3].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2978,9 +2182,7 @@ public void test2() throws Throwable { } value = msg.states[3].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2988,9 +2190,7 @@ public void test2() throws Throwable { } value = msg.states[3].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.sat + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.sat + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -2998,9 +2198,7 @@ public void test2() throws Throwable { } value = msg.states[3].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[3].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3009,9 +2207,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[4].cn0, 4.20329055786132812e+01, DELTA); value = msg.states[4].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3019,9 +2215,7 @@ public void test2() throws Throwable { } value = msg.states[4].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3029,9 +2223,7 @@ public void test2() throws Throwable { } value = msg.states[4].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.sat + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.sat + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -3039,9 +2231,7 @@ public void test2() throws Throwable { } value = msg.states[4].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[4].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3050,9 +2240,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[5].cn0, 3.74354667663574219e+01, DELTA); value = msg.states[5].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3060,9 +2248,7 @@ public void test2() throws Throwable { } value = msg.states[5].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3070,9 +2256,7 @@ public void test2() throws Throwable { } value = msg.states[5].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.sat + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.sat + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -3080,9 +2264,7 @@ public void test2() throws Throwable { } value = msg.states[5].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[5].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3091,9 +2273,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[6].cn0, 3.84229621887207031e+01, DELTA); value = msg.states[6].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3101,9 +2281,7 @@ public void test2() throws Throwable { } value = msg.states[6].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3111,9 +2289,7 @@ public void test2() throws Throwable { } value = msg.states[6].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.sat + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.sat + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -3121,9 +2297,7 @@ public void test2() throws Throwable { } value = msg.states[6].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[6].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3132,9 +2306,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[7].cn0, 3.89152030944824219e+01, DELTA); value = msg.states[7].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3142,9 +2314,7 @@ public void test2() throws Throwable { } value = msg.states[7].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3152,9 +2322,7 @@ public void test2() throws Throwable { } value = msg.states[7].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.sat + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.sat + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -3162,9 +2330,7 @@ public void test2() throws Throwable { } value = msg.states[7].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[7].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3173,9 +2339,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[8].cn0, 4.26225929260253906e+01, DELTA); value = msg.states[8].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3183,9 +2347,7 @@ public void test2() throws Throwable { } value = msg.states[8].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3193,9 +2355,7 @@ public void test2() throws Throwable { } value = msg.states[8].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.sat + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.sat + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -3203,9 +2363,7 @@ public void test2() throws Throwable { } value = msg.states[8].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[8].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3214,9 +2372,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[9].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[9].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3224,9 +2380,7 @@ public void test2() throws Throwable { } value = msg.states[9].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3234,9 +2388,7 @@ public void test2() throws Throwable { } value = msg.states[9].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3244,9 +2396,7 @@ public void test2() throws Throwable { } value = msg.states[9].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3255,9 +2405,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[10].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[10].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3265,9 +2413,7 @@ public void test2() throws Throwable { } value = msg.states[10].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3275,9 +2421,7 @@ public void test2() throws Throwable { } value = msg.states[10].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3285,9 +2429,7 @@ public void test2() throws Throwable { } value = msg.states[10].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3301,35 +2443,16 @@ public void test2() throws Throwable { public void test3() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateTest.test3"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 202, (byte) 0, (byte) 0, (byte) 0, (byte) 250, (byte) 249, - (byte) 27, (byte) 66, (byte) 1, (byte) 203, (byte) 0, (byte) 0, (byte) 0, - (byte) 40, (byte) 143, (byte) 11, (byte) 66, (byte) 1, (byte) 208, (byte) 0, - (byte) 0, (byte) 0, (byte) 190, (byte) 200, (byte) 21, (byte) 66, (byte) 1, - (byte) 212, (byte) 0, (byte) 0, (byte) 0, (byte) 251, (byte) 233, (byte) 26, - (byte) 66, (byte) 1, (byte) 217, (byte) 0, (byte) 0, (byte) 0, (byte) 209, - (byte) 238, (byte) 39, (byte) 66, (byte) 1, (byte) 218, (byte) 0, (byte) 0, - (byte) 0, (byte) 162, (byte) 219, (byte) 21, (byte) 66, (byte) 1, (byte) 220, - (byte) 0, (byte) 0, (byte) 0, (byte) 162, (byte) 197, (byte) 25, (byte) 66, - (byte) 1, (byte) 222, (byte) 0, (byte) 0, (byte) 0, (byte) 14, (byte) 35, - (byte) 28, (byte) 66, (byte) 1, (byte) 225, (byte) 0, (byte) 0, (byte) 0, - (byte) 9, (byte) 153, (byte) 43, (byte) 66, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, - (byte) 191, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x13, payload); - MsgTrackingStateDepB msg = new MsgTrackingStateDepB(sbp); + byte[] payload = new byte[] {(byte)1,(byte)202,(byte)0,(byte)0,(byte)0,(byte)250,(byte)249,(byte)27,(byte)66,(byte)1,(byte)203,(byte)0,(byte)0,(byte)0,(byte)40,(byte)143,(byte)11,(byte)66,(byte)1,(byte)208,(byte)0,(byte)0,(byte)0,(byte)190,(byte)200,(byte)21,(byte)66,(byte)1,(byte)212,(byte)0,(byte)0,(byte)0,(byte)251,(byte)233,(byte)26,(byte)66,(byte)1,(byte)217,(byte)0,(byte)0,(byte)0,(byte)209,(byte)238,(byte)39,(byte)66,(byte)1,(byte)218,(byte)0,(byte)0,(byte)0,(byte)162,(byte)219,(byte)21,(byte)66,(byte)1,(byte)220,(byte)0,(byte)0,(byte)0,(byte)162,(byte)197,(byte)25,(byte)66,(byte)1,(byte)222,(byte)0,(byte)0,(byte)0,(byte)14,(byte)35,(byte)28,(byte)66,(byte)1,(byte)225,(byte)0,(byte)0,(byte)0,(byte)9,(byte)153,(byte)43,(byte)66,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x13, payload ); + MsgTrackingStateDepB msg = new MsgTrackingStateDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.states[0].cn0, 3.89941177368164062e+01, DELTA); value = msg.states[0].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3337,9 +2460,7 @@ public void test3() throws Throwable { } value = msg.states[0].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3347,9 +2468,7 @@ public void test3() throws Throwable { } value = msg.states[0].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.sat + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.sat + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -3357,9 +2476,7 @@ public void test3() throws Throwable { } value = msg.states[0].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[0].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3368,9 +2485,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[1].cn0, 3.48898010253906250e+01, DELTA); value = msg.states[1].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3378,9 +2493,7 @@ public void test3() throws Throwable { } value = msg.states[1].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3388,9 +2501,7 @@ public void test3() throws Throwable { } value = msg.states[1].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.sat + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.sat + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -3398,9 +2509,7 @@ public void test3() throws Throwable { } value = msg.states[1].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[1].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3409,9 +2518,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[2].cn0, 3.74460372924804688e+01, DELTA); value = msg.states[2].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3419,9 +2526,7 @@ public void test3() throws Throwable { } value = msg.states[2].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3429,9 +2534,7 @@ public void test3() throws Throwable { } value = msg.states[2].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.sat + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.sat + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -3439,9 +2542,7 @@ public void test3() throws Throwable { } value = msg.states[2].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[2].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3450,9 +2551,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[3].cn0, 3.87284965515136719e+01, DELTA); value = msg.states[3].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3460,9 +2559,7 @@ public void test3() throws Throwable { } value = msg.states[3].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3470,9 +2567,7 @@ public void test3() throws Throwable { } value = msg.states[3].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.sat + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.sat + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -3480,9 +2575,7 @@ public void test3() throws Throwable { } value = msg.states[3].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[3].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3491,9 +2584,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[4].cn0, 4.19832191467285156e+01, DELTA); value = msg.states[4].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3501,9 +2592,7 @@ public void test3() throws Throwable { } value = msg.states[4].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3511,9 +2600,7 @@ public void test3() throws Throwable { } value = msg.states[4].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.sat + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.sat + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -3521,9 +2608,7 @@ public void test3() throws Throwable { } value = msg.states[4].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[4].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3532,9 +2617,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[5].cn0, 3.74644851684570312e+01, DELTA); value = msg.states[5].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3542,9 +2625,7 @@ public void test3() throws Throwable { } value = msg.states[5].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3552,9 +2633,7 @@ public void test3() throws Throwable { } value = msg.states[5].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.sat + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.sat + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -3562,9 +2641,7 @@ public void test3() throws Throwable { } value = msg.states[5].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[5].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3573,9 +2650,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[6].cn0, 3.84430007934570312e+01, DELTA); value = msg.states[6].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3583,9 +2658,7 @@ public void test3() throws Throwable { } value = msg.states[6].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3593,9 +2666,7 @@ public void test3() throws Throwable { } value = msg.states[6].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.sat + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.sat + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -3603,9 +2674,7 @@ public void test3() throws Throwable { } value = msg.states[6].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[6].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3614,9 +2683,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[7].cn0, 3.90342330932617188e+01, DELTA); value = msg.states[7].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3624,9 +2691,7 @@ public void test3() throws Throwable { } value = msg.states[7].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3634,9 +2699,7 @@ public void test3() throws Throwable { } value = msg.states[7].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.sat + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.sat + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -3644,9 +2707,7 @@ public void test3() throws Throwable { } value = msg.states[7].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[7].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3655,9 +2716,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[8].cn0, 4.28994483947753906e+01, DELTA); value = msg.states[8].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3665,9 +2724,7 @@ public void test3() throws Throwable { } value = msg.states[8].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3675,9 +2732,7 @@ public void test3() throws Throwable { } value = msg.states[8].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.sat + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.sat + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -3685,9 +2740,7 @@ public void test3() throws Throwable { } value = msg.states[8].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[8].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3696,9 +2749,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[9].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[9].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3706,9 +2757,7 @@ public void test3() throws Throwable { } value = msg.states[9].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3716,9 +2765,7 @@ public void test3() throws Throwable { } value = msg.states[9].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3726,9 +2773,7 @@ public void test3() throws Throwable { } value = msg.states[9].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3737,9 +2782,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[10].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[10].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3747,9 +2790,7 @@ public void test3() throws Throwable { } value = msg.states[10].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3757,9 +2798,7 @@ public void test3() throws Throwable { } value = msg.states[10].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3767,9 +2806,7 @@ public void test3() throws Throwable { } value = msg.states[10].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3783,35 +2820,16 @@ public void test3() throws Throwable { public void test4() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateTest.test4"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 202, (byte) 0, (byte) 0, (byte) 0, (byte) 123, (byte) 209, - (byte) 27, (byte) 66, (byte) 1, (byte) 203, (byte) 0, (byte) 0, (byte) 0, - (byte) 214, (byte) 64, (byte) 15, (byte) 66, (byte) 1, (byte) 208, (byte) 0, - (byte) 0, (byte) 0, (byte) 56, (byte) 55, (byte) 22, (byte) 66, (byte) 1, - (byte) 212, (byte) 0, (byte) 0, (byte) 0, (byte) 91, (byte) 142, (byte) 27, - (byte) 66, (byte) 1, (byte) 217, (byte) 0, (byte) 0, (byte) 0, (byte) 253, - (byte) 154, (byte) 41, (byte) 66, (byte) 1, (byte) 218, (byte) 0, (byte) 0, - (byte) 0, (byte) 128, (byte) 142, (byte) 22, (byte) 66, (byte) 1, (byte) 220, - (byte) 0, (byte) 0, (byte) 0, (byte) 17, (byte) 174, (byte) 23, (byte) 66, - (byte) 1, (byte) 222, (byte) 0, (byte) 0, (byte) 0, (byte) 155, (byte) 2, - (byte) 29, (byte) 66, (byte) 1, (byte) 225, (byte) 0, (byte) 0, (byte) 0, - (byte) 162, (byte) 100, (byte) 42, (byte) 66, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, - (byte) 191, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x13, payload); - MsgTrackingStateDepB msg = new MsgTrackingStateDepB(sbp); + byte[] payload = new byte[] {(byte)1,(byte)202,(byte)0,(byte)0,(byte)0,(byte)123,(byte)209,(byte)27,(byte)66,(byte)1,(byte)203,(byte)0,(byte)0,(byte)0,(byte)214,(byte)64,(byte)15,(byte)66,(byte)1,(byte)208,(byte)0,(byte)0,(byte)0,(byte)56,(byte)55,(byte)22,(byte)66,(byte)1,(byte)212,(byte)0,(byte)0,(byte)0,(byte)91,(byte)142,(byte)27,(byte)66,(byte)1,(byte)217,(byte)0,(byte)0,(byte)0,(byte)253,(byte)154,(byte)41,(byte)66,(byte)1,(byte)218,(byte)0,(byte)0,(byte)0,(byte)128,(byte)142,(byte)22,(byte)66,(byte)1,(byte)220,(byte)0,(byte)0,(byte)0,(byte)17,(byte)174,(byte)23,(byte)66,(byte)1,(byte)222,(byte)0,(byte)0,(byte)0,(byte)155,(byte)2,(byte)29,(byte)66,(byte)1,(byte)225,(byte)0,(byte)0,(byte)0,(byte)162,(byte)100,(byte)42,(byte)66,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x13, payload ); + MsgTrackingStateDepB msg = new MsgTrackingStateDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.states[0].cn0, 3.89545707702636719e+01, DELTA); value = msg.states[0].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3819,9 +2837,7 @@ public void test4() throws Throwable { } value = msg.states[0].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3829,9 +2845,7 @@ public void test4() throws Throwable { } value = msg.states[0].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.sat + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.sat + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -3839,9 +2853,7 @@ public void test4() throws Throwable { } value = msg.states[0].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[0].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3850,9 +2862,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[1].cn0, 3.58133163452148438e+01, DELTA); value = msg.states[1].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3860,9 +2870,7 @@ public void test4() throws Throwable { } value = msg.states[1].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3870,9 +2878,7 @@ public void test4() throws Throwable { } value = msg.states[1].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.sat + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.sat + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -3880,9 +2886,7 @@ public void test4() throws Throwable { } value = msg.states[1].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[1].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3891,9 +2895,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[2].cn0, 3.75539245605468750e+01, DELTA); value = msg.states[2].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3901,9 +2903,7 @@ public void test4() throws Throwable { } value = msg.states[2].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3911,9 +2911,7 @@ public void test4() throws Throwable { } value = msg.states[2].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.sat + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.sat + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -3921,9 +2919,7 @@ public void test4() throws Throwable { } value = msg.states[2].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[2].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3932,9 +2928,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[3].cn0, 3.88890190124511719e+01, DELTA); value = msg.states[3].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3942,9 +2936,7 @@ public void test4() throws Throwable { } value = msg.states[3].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3952,9 +2944,7 @@ public void test4() throws Throwable { } value = msg.states[3].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.sat + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.sat + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -3962,9 +2952,7 @@ public void test4() throws Throwable { } value = msg.states[3].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[3].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -3973,9 +2961,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[4].cn0, 4.24013557434082031e+01, DELTA); value = msg.states[4].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3983,9 +2969,7 @@ public void test4() throws Throwable { } value = msg.states[4].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -3993,9 +2977,7 @@ public void test4() throws Throwable { } value = msg.states[4].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.sat + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.sat + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -4003,9 +2985,7 @@ public void test4() throws Throwable { } value = msg.states[4].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[4].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4014,9 +2994,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[5].cn0, 3.76391601562500000e+01, DELTA); value = msg.states[5].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4024,9 +3002,7 @@ public void test4() throws Throwable { } value = msg.states[5].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4034,9 +3010,7 @@ public void test4() throws Throwable { } value = msg.states[5].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.sat + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.sat + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -4044,9 +3018,7 @@ public void test4() throws Throwable { } value = msg.states[5].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[5].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4055,9 +3027,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[6].cn0, 3.79199867248535156e+01, DELTA); value = msg.states[6].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4065,9 +3035,7 @@ public void test4() throws Throwable { } value = msg.states[6].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4075,9 +3043,7 @@ public void test4() throws Throwable { } value = msg.states[6].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.sat + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.sat + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -4085,9 +3051,7 @@ public void test4() throws Throwable { } value = msg.states[6].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[6].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4096,9 +3060,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[7].cn0, 3.92525444030761719e+01, DELTA); value = msg.states[7].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4106,9 +3068,7 @@ public void test4() throws Throwable { } value = msg.states[7].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4116,9 +3076,7 @@ public void test4() throws Throwable { } value = msg.states[7].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.sat + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.sat + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -4126,9 +3084,7 @@ public void test4() throws Throwable { } value = msg.states[7].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[7].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4137,9 +3093,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[8].cn0, 4.25982742309570312e+01, DELTA); value = msg.states[8].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4147,9 +3101,7 @@ public void test4() throws Throwable { } value = msg.states[8].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4157,9 +3109,7 @@ public void test4() throws Throwable { } value = msg.states[8].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.sat + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.sat + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -4167,9 +3117,7 @@ public void test4() throws Throwable { } value = msg.states[8].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[8].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4178,9 +3126,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[9].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[9].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4188,9 +3134,7 @@ public void test4() throws Throwable { } value = msg.states[9].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4198,9 +3142,7 @@ public void test4() throws Throwable { } value = msg.states[9].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4208,9 +3150,7 @@ public void test4() throws Throwable { } value = msg.states[9].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4219,9 +3159,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[10].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[10].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4229,9 +3167,7 @@ public void test4() throws Throwable { } value = msg.states[10].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4239,9 +3175,7 @@ public void test4() throws Throwable { } value = msg.states[10].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4249,9 +3183,7 @@ public void test4() throws Throwable { } value = msg.states[10].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4265,35 +3197,16 @@ public void test4() throws Throwable { public void test5() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateTest.test5"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 202, (byte) 0, (byte) 0, (byte) 0, (byte) 120, (byte) 122, - (byte) 29, (byte) 66, (byte) 1, (byte) 203, (byte) 0, (byte) 0, (byte) 0, - (byte) 66, (byte) 22, (byte) 18, (byte) 66, (byte) 1, (byte) 208, (byte) 0, - (byte) 0, (byte) 0, (byte) 153, (byte) 163, (byte) 24, (byte) 66, (byte) 1, - (byte) 212, (byte) 0, (byte) 0, (byte) 0, (byte) 178, (byte) 204, (byte) 28, - (byte) 66, (byte) 1, (byte) 217, (byte) 0, (byte) 0, (byte) 0, (byte) 220, - (byte) 59, (byte) 38, (byte) 66, (byte) 1, (byte) 218, (byte) 0, (byte) 0, - (byte) 0, (byte) 161, (byte) 27, (byte) 20, (byte) 66, (byte) 1, (byte) 220, - (byte) 0, (byte) 0, (byte) 0, (byte) 125, (byte) 107, (byte) 24, (byte) 66, - (byte) 1, (byte) 222, (byte) 0, (byte) 0, (byte) 0, (byte) 242, (byte) 46, - (byte) 28, (byte) 66, (byte) 1, (byte) 225, (byte) 0, (byte) 0, (byte) 0, - (byte) 231, (byte) 130, (byte) 41, (byte) 66, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, - (byte) 191, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x13, payload); - MsgTrackingStateDepB msg = new MsgTrackingStateDepB(sbp); + byte[] payload = new byte[] {(byte)1,(byte)202,(byte)0,(byte)0,(byte)0,(byte)120,(byte)122,(byte)29,(byte)66,(byte)1,(byte)203,(byte)0,(byte)0,(byte)0,(byte)66,(byte)22,(byte)18,(byte)66,(byte)1,(byte)208,(byte)0,(byte)0,(byte)0,(byte)153,(byte)163,(byte)24,(byte)66,(byte)1,(byte)212,(byte)0,(byte)0,(byte)0,(byte)178,(byte)204,(byte)28,(byte)66,(byte)1,(byte)217,(byte)0,(byte)0,(byte)0,(byte)220,(byte)59,(byte)38,(byte)66,(byte)1,(byte)218,(byte)0,(byte)0,(byte)0,(byte)161,(byte)27,(byte)20,(byte)66,(byte)1,(byte)220,(byte)0,(byte)0,(byte)0,(byte)125,(byte)107,(byte)24,(byte)66,(byte)1,(byte)222,(byte)0,(byte)0,(byte)0,(byte)242,(byte)46,(byte)28,(byte)66,(byte)1,(byte)225,(byte)0,(byte)0,(byte)0,(byte)231,(byte)130,(byte)41,(byte)66,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x13, payload ); + MsgTrackingStateDepB msg = new MsgTrackingStateDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.states[0].cn0, 3.93695983886718750e+01, DELTA); value = msg.states[0].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4301,9 +3214,7 @@ public void test5() throws Throwable { } value = msg.states[0].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4311,9 +3222,7 @@ public void test5() throws Throwable { } value = msg.states[0].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.sat + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.sat + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -4321,9 +3230,7 @@ public void test5() throws Throwable { } value = msg.states[0].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[0].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4332,9 +3239,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[1].cn0, 3.65217361450195312e+01, DELTA); value = msg.states[1].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4342,9 +3247,7 @@ public void test5() throws Throwable { } value = msg.states[1].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4352,9 +3255,7 @@ public void test5() throws Throwable { } value = msg.states[1].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.sat + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.sat + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -4362,9 +3263,7 @@ public void test5() throws Throwable { } value = msg.states[1].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[1].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4373,9 +3272,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[2].cn0, 3.81597633361816406e+01, DELTA); value = msg.states[2].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4383,9 +3280,7 @@ public void test5() throws Throwable { } value = msg.states[2].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4393,9 +3288,7 @@ public void test5() throws Throwable { } value = msg.states[2].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.sat + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.sat + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -4403,9 +3296,7 @@ public void test5() throws Throwable { } value = msg.states[2].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[2].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4414,9 +3305,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[3].cn0, 3.91998977661132812e+01, DELTA); value = msg.states[3].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4424,9 +3313,7 @@ public void test5() throws Throwable { } value = msg.states[3].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4434,9 +3321,7 @@ public void test5() throws Throwable { } value = msg.states[3].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.sat + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.sat + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -4444,9 +3329,7 @@ public void test5() throws Throwable { } value = msg.states[3].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[3].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4455,9 +3338,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[4].cn0, 4.15584564208984375e+01, DELTA); value = msg.states[4].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4465,9 +3346,7 @@ public void test5() throws Throwable { } value = msg.states[4].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4475,9 +3354,7 @@ public void test5() throws Throwable { } value = msg.states[4].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.sat + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.sat + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -4485,9 +3362,7 @@ public void test5() throws Throwable { } value = msg.states[4].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[4].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4496,9 +3371,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[5].cn0, 3.70269813537597656e+01, DELTA); value = msg.states[5].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4506,9 +3379,7 @@ public void test5() throws Throwable { } value = msg.states[5].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4516,9 +3387,7 @@ public void test5() throws Throwable { } value = msg.states[5].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.sat + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.sat + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -4526,9 +3395,7 @@ public void test5() throws Throwable { } value = msg.states[5].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[5].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4537,9 +3404,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[6].cn0, 3.81049690246582031e+01, DELTA); value = msg.states[6].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4547,9 +3412,7 @@ public void test5() throws Throwable { } value = msg.states[6].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4557,9 +3420,7 @@ public void test5() throws Throwable { } value = msg.states[6].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.sat + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.sat + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -4567,9 +3428,7 @@ public void test5() throws Throwable { } value = msg.states[6].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[6].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4578,9 +3437,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[7].cn0, 3.90458450317382812e+01, DELTA); value = msg.states[7].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4588,9 +3445,7 @@ public void test5() throws Throwable { } value = msg.states[7].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4598,9 +3453,7 @@ public void test5() throws Throwable { } value = msg.states[7].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.sat + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.sat + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -4608,9 +3461,7 @@ public void test5() throws Throwable { } value = msg.states[7].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[7].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4619,9 +3470,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[8].cn0, 4.23778343200683594e+01, DELTA); value = msg.states[8].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4629,9 +3478,7 @@ public void test5() throws Throwable { } value = msg.states[8].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4639,9 +3486,7 @@ public void test5() throws Throwable { } value = msg.states[8].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.sat + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.sat + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -4649,9 +3494,7 @@ public void test5() throws Throwable { } value = msg.states[8].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[8].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4660,9 +3503,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[9].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[9].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4670,9 +3511,7 @@ public void test5() throws Throwable { } value = msg.states[9].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4680,9 +3519,7 @@ public void test5() throws Throwable { } value = msg.states[9].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4690,9 +3527,7 @@ public void test5() throws Throwable { } value = msg.states[9].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4701,9 +3536,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[10].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[10].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4711,9 +3544,7 @@ public void test5() throws Throwable { } value = msg.states[10].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4721,9 +3552,7 @@ public void test5() throws Throwable { } value = msg.states[10].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4731,9 +3560,7 @@ public void test5() throws Throwable { } value = msg.states[10].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4747,35 +3574,16 @@ public void test5() throws Throwable { public void test6() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgTrackingStateTest.test6"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 202, (byte) 0, (byte) 0, (byte) 0, (byte) 103, (byte) 208, - (byte) 30, (byte) 66, (byte) 1, (byte) 203, (byte) 0, (byte) 0, (byte) 0, - (byte) 117, (byte) 24, (byte) 18, (byte) 66, (byte) 1, (byte) 208, (byte) 0, - (byte) 0, (byte) 0, (byte) 200, (byte) 173, (byte) 20, (byte) 66, (byte) 1, - (byte) 212, (byte) 0, (byte) 0, (byte) 0, (byte) 137, (byte) 68, (byte) 27, - (byte) 66, (byte) 1, (byte) 217, (byte) 0, (byte) 0, (byte) 0, (byte) 243, - (byte) 51, (byte) 40, (byte) 66, (byte) 1, (byte) 218, (byte) 0, (byte) 0, - (byte) 0, (byte) 225, (byte) 58, (byte) 23, (byte) 66, (byte) 1, (byte) 220, - (byte) 0, (byte) 0, (byte) 0, (byte) 132, (byte) 221, (byte) 22, (byte) 66, - (byte) 1, (byte) 222, (byte) 0, (byte) 0, (byte) 0, (byte) 157, (byte) 29, - (byte) 26, (byte) 66, (byte) 1, (byte) 225, (byte) 0, (byte) 0, (byte) 0, - (byte) 133, (byte) 21, (byte) 41, (byte) 66, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, - (byte) 191, - }; - SBPMessage sbp = new SBPMessage(0xd7f6, 0x13, payload); - MsgTrackingStateDepB msg = new MsgTrackingStateDepB(sbp); + byte[] payload = new byte[] {(byte)1,(byte)202,(byte)0,(byte)0,(byte)0,(byte)103,(byte)208,(byte)30,(byte)66,(byte)1,(byte)203,(byte)0,(byte)0,(byte)0,(byte)117,(byte)24,(byte)18,(byte)66,(byte)1,(byte)208,(byte)0,(byte)0,(byte)0,(byte)200,(byte)173,(byte)20,(byte)66,(byte)1,(byte)212,(byte)0,(byte)0,(byte)0,(byte)137,(byte)68,(byte)27,(byte)66,(byte)1,(byte)217,(byte)0,(byte)0,(byte)0,(byte)243,(byte)51,(byte)40,(byte)66,(byte)1,(byte)218,(byte)0,(byte)0,(byte)0,(byte)225,(byte)58,(byte)23,(byte)66,(byte)1,(byte)220,(byte)0,(byte)0,(byte)0,(byte)132,(byte)221,(byte)22,(byte)66,(byte)1,(byte)222,(byte)0,(byte)0,(byte)0,(byte)157,(byte)29,(byte)26,(byte)66,(byte)1,(byte)225,(byte)0,(byte)0,(byte)0,(byte)133,(byte)21,(byte)41,(byte)66,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191, }; + SBPMessage sbp = new SBPMessage( 0xd7f6, 0x13, payload ); + MsgTrackingStateDepB msg = new MsgTrackingStateDepB( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.states[0].cn0, 3.97035179138183594e+01, DELTA); value = msg.states[0].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4783,9 +3591,7 @@ public void test6() throws Throwable { } value = msg.states[0].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4793,9 +3599,7 @@ public void test6() throws Throwable { } value = msg.states[0].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].sid.sat + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.states[0].sid.sat + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -4803,9 +3607,7 @@ public void test6() throws Throwable { } value = msg.states[0].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[0].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4814,9 +3616,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[1].cn0, 3.65238838195800781e+01, DELTA); value = msg.states[1].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4824,9 +3624,7 @@ public void test6() throws Throwable { } value = msg.states[1].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4834,9 +3632,7 @@ public void test6() throws Throwable { } value = msg.states[1].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].sid.sat + "' != '" + 203 + "'", - value.equals(BigInteger.valueOf(203L))); + org.junit.Assert.assertTrue("'" + msg.states[1].sid.sat + "' != '" + 203 + "'", value.equals(BigInteger.valueOf( 203L ) ) ); } else { value = value.longValue(); expected = 203L; @@ -4844,9 +3640,7 @@ public void test6() throws Throwable { } value = msg.states[1].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[1].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4855,9 +3649,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[2].cn0, 3.71697082519531250e+01, DELTA); value = msg.states[2].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4865,9 +3657,7 @@ public void test6() throws Throwable { } value = msg.states[2].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4875,9 +3665,7 @@ public void test6() throws Throwable { } value = msg.states[2].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].sid.sat + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.states[2].sid.sat + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -4885,9 +3673,7 @@ public void test6() throws Throwable { } value = msg.states[2].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[2].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4896,9 +3682,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[3].cn0, 3.88169288635253906e+01, DELTA); value = msg.states[3].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4906,9 +3690,7 @@ public void test6() throws Throwable { } value = msg.states[3].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4916,9 +3698,7 @@ public void test6() throws Throwable { } value = msg.states[3].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].sid.sat + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.states[3].sid.sat + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -4926,9 +3706,7 @@ public void test6() throws Throwable { } value = msg.states[3].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[3].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4937,9 +3715,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[4].cn0, 4.20507316589355469e+01, DELTA); value = msg.states[4].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4947,9 +3723,7 @@ public void test6() throws Throwable { } value = msg.states[4].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4957,9 +3731,7 @@ public void test6() throws Throwable { } value = msg.states[4].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].sid.sat + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.states[4].sid.sat + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -4967,9 +3739,7 @@ public void test6() throws Throwable { } value = msg.states[4].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[4].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -4978,9 +3748,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[5].cn0, 3.78074989318847656e+01, DELTA); value = msg.states[5].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4988,9 +3756,7 @@ public void test6() throws Throwable { } value = msg.states[5].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -4998,9 +3764,7 @@ public void test6() throws Throwable { } value = msg.states[5].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].sid.sat + "' != '" + 218 + "'", - value.equals(BigInteger.valueOf(218L))); + org.junit.Assert.assertTrue("'" + msg.states[5].sid.sat + "' != '" + 218 + "'", value.equals(BigInteger.valueOf( 218L ) ) ); } else { value = value.longValue(); expected = 218L; @@ -5008,9 +3772,7 @@ public void test6() throws Throwable { } value = msg.states[5].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[5].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -5019,9 +3781,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[6].cn0, 3.77163238525390625e+01, DELTA); value = msg.states[6].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5029,9 +3789,7 @@ public void test6() throws Throwable { } value = msg.states[6].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5039,9 +3797,7 @@ public void test6() throws Throwable { } value = msg.states[6].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].sid.sat + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.states[6].sid.sat + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -5049,9 +3805,7 @@ public void test6() throws Throwable { } value = msg.states[6].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[6].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -5060,9 +3814,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[7].cn0, 3.85289192199707031e+01, DELTA); value = msg.states[7].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5070,9 +3822,7 @@ public void test6() throws Throwable { } value = msg.states[7].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5080,9 +3830,7 @@ public void test6() throws Throwable { } value = msg.states[7].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].sid.sat + "' != '" + 222 + "'", - value.equals(BigInteger.valueOf(222L))); + org.junit.Assert.assertTrue("'" + msg.states[7].sid.sat + "' != '" + 222 + "'", value.equals(BigInteger.valueOf( 222L ) ) ); } else { value = value.longValue(); expected = 222L; @@ -5090,9 +3838,7 @@ public void test6() throws Throwable { } value = msg.states[7].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[7].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -5101,9 +3847,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[8].cn0, 4.22710151672363281e+01, DELTA); value = msg.states[8].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5111,9 +3855,7 @@ public void test6() throws Throwable { } value = msg.states[8].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5121,9 +3863,7 @@ public void test6() throws Throwable { } value = msg.states[8].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].sid.sat + "' != '" + 225 + "'", - value.equals(BigInteger.valueOf(225L))); + org.junit.Assert.assertTrue("'" + msg.states[8].sid.sat + "' != '" + 225 + "'", value.equals(BigInteger.valueOf( 225L ) ) ); } else { value = value.longValue(); expected = 225L; @@ -5131,9 +3871,7 @@ public void test6() throws Throwable { } value = msg.states[8].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[8].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -5142,9 +3880,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[9].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[9].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5152,9 +3888,7 @@ public void test6() throws Throwable { } value = msg.states[9].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5162,9 +3896,7 @@ public void test6() throws Throwable { } value = msg.states[9].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].sid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].sid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5172,9 +3904,7 @@ public void test6() throws Throwable { } value = msg.states[9].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5183,9 +3913,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[10].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[10].sid.code; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.code + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.code + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5193,9 +3921,7 @@ public void test6() throws Throwable { } value = msg.states[10].sid.reserved; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.reserved + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.reserved + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5203,9 +3929,7 @@ public void test6() throws Throwable { } value = msg.states[10].sid.sat; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].sid.sat + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].sid.sat + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -5213,9 +3937,7 @@ public void test6() throws Throwable { } value = msg.states[10].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; diff --git a/java/test/auto_check_sbp_tracking_MsgtrackingStateDepATest.java b/java/test/auto_check_sbp_tracking_MsgtrackingStateDepATest.java index 70ba89487..19fdb6556 100644 --- a/java/test/auto_check_sbp_tracking_MsgtrackingStateDepATest.java +++ b/java/test/auto_check_sbp_tracking_MsgtrackingStateDepATest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,18 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/tracking/test_MsgtrackingStateDepA.yaml by generate.py. Do not -// modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/tracking/test_MsgtrackingStateDepA.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.tracking.MsgTrackingStateDepA; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_tracking_MsgtrackingStateDepATest { @@ -30,30 +34,16 @@ public class auto_check_sbp_tracking_MsgtrackingStateDepATest { public void test1() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgtrackingStateDepATest.test1"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 0, (byte) 204, (byte) 177, (byte) 51, (byte) 65, (byte) 1, - (byte) 2, (byte) 198, (byte) 4, (byte) 39, (byte) 65, (byte) 1, (byte) 3, - (byte) 219, (byte) 182, (byte) 27, (byte) 65, (byte) 1, (byte) 7, (byte) 132, - (byte) 120, (byte) 101, (byte) 65, (byte) 1, (byte) 10, (byte) 91, (byte) 91, - (byte) 251, (byte) 64, (byte) 1, (byte) 13, (byte) 42, (byte) 37, (byte) 163, - (byte) 64, (byte) 1, (byte) 22, (byte) 130, (byte) 184, (byte) 215, (byte) 64, - (byte) 1, (byte) 30, (byte) 115, (byte) 53, (byte) 75, (byte) 65, (byte) 1, - (byte) 31, (byte) 16, (byte) 74, (byte) 126, (byte) 65, (byte) 1, (byte) 25, - (byte) 132, (byte) 196, (byte) 135, (byte) 64, (byte) 1, (byte) 6, (byte) 100, - (byte) 59, (byte) 223, (byte) 64, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x16, payload); - MsgTrackingStateDepA msg = new MsgTrackingStateDepA(sbp); + byte[] payload = new byte[] {(byte)1,(byte)0,(byte)204,(byte)177,(byte)51,(byte)65,(byte)1,(byte)2,(byte)198,(byte)4,(byte)39,(byte)65,(byte)1,(byte)3,(byte)219,(byte)182,(byte)27,(byte)65,(byte)1,(byte)7,(byte)132,(byte)120,(byte)101,(byte)65,(byte)1,(byte)10,(byte)91,(byte)91,(byte)251,(byte)64,(byte)1,(byte)13,(byte)42,(byte)37,(byte)163,(byte)64,(byte)1,(byte)22,(byte)130,(byte)184,(byte)215,(byte)64,(byte)1,(byte)30,(byte)115,(byte)53,(byte)75,(byte)65,(byte)1,(byte)31,(byte)16,(byte)74,(byte)126,(byte)65,(byte)1,(byte)25,(byte)132,(byte)196,(byte)135,(byte)64,(byte)1,(byte)6,(byte)100,(byte)59,(byte)223,(byte)64, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x16, payload ); + MsgTrackingStateDepA msg = new MsgTrackingStateDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.states[0].cn0, 1.12309074401855469e+01, DELTA); value = msg.states[0].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -61,9 +51,7 @@ public void test1() throws Throwable { } value = msg.states[0].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[0].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -72,9 +60,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[1].cn0, 1.04386653900146484e+01, DELTA); value = msg.states[1].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].prn + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.states[1].prn + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -82,9 +68,7 @@ public void test1() throws Throwable { } value = msg.states[1].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[1].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -93,9 +77,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[2].cn0, 9.73214244842529297e+00, DELTA); value = msg.states[2].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].prn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[2].prn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -103,9 +85,7 @@ public void test1() throws Throwable { } value = msg.states[2].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[2].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -114,9 +94,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[3].cn0, 1.43419227600097656e+01, DELTA); value = msg.states[3].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].prn + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.states[3].prn + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -124,9 +102,7 @@ public void test1() throws Throwable { } value = msg.states[3].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[3].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -135,9 +111,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[4].cn0, 7.85490179061889648e+00, DELTA); value = msg.states[4].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].prn + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.states[4].prn + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -145,9 +119,7 @@ public void test1() throws Throwable { } value = msg.states[4].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[4].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -156,9 +128,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[5].cn0, 5.09828662872314453e+00, DELTA); value = msg.states[5].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].prn + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.states[5].prn + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -166,9 +136,7 @@ public void test1() throws Throwable { } value = msg.states[5].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[5].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -177,9 +145,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[6].cn0, 6.74127292633056641e+00, DELTA); value = msg.states[6].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].prn + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.states[6].prn + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -187,9 +153,7 @@ public void test1() throws Throwable { } value = msg.states[6].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[6].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -198,9 +162,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[7].cn0, 1.27005491256713867e+01, DELTA); value = msg.states[7].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].prn + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.states[7].prn + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -208,9 +170,7 @@ public void test1() throws Throwable { } value = msg.states[7].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[7].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -219,9 +179,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[8].cn0, 1.58930816650390625e+01, DELTA); value = msg.states[8].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].prn + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.states[8].prn + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -229,9 +187,7 @@ public void test1() throws Throwable { } value = msg.states[8].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[8].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -240,9 +196,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[9].cn0, 4.24273872375488281e+00, DELTA); value = msg.states[9].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].prn + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.states[9].prn + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -250,9 +204,7 @@ public void test1() throws Throwable { } value = msg.states[9].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[9].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -261,9 +213,7 @@ public void test1() throws Throwable { org.junit.Assert.assertEquals(msg.states[10].cn0, 6.97599983215332031e+00, DELTA); value = msg.states[10].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].prn + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.states[10].prn + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -271,9 +221,7 @@ public void test1() throws Throwable { } value = msg.states[10].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[10].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -287,30 +235,16 @@ public void test1() throws Throwable { public void test2() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgtrackingStateDepATest.test2"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 0, (byte) 216, (byte) 57, (byte) 48, (byte) 65, (byte) 1, - (byte) 2, (byte) 145, (byte) 41, (byte) 46, (byte) 65, (byte) 1, (byte) 3, - (byte) 4, (byte) 26, (byte) 34, (byte) 65, (byte) 1, (byte) 7, (byte) 177, - (byte) 67, (byte) 109, (byte) 65, (byte) 1, (byte) 10, (byte) 61, (byte) 80, - (byte) 249, (byte) 64, (byte) 1, (byte) 13, (byte) 250, (byte) 199, (byte) 155, - (byte) 64, (byte) 1, (byte) 22, (byte) 55, (byte) 19, (byte) 215, (byte) 64, - (byte) 1, (byte) 30, (byte) 138, (byte) 138, (byte) 79, (byte) 65, (byte) 1, - (byte) 31, (byte) 214, (byte) 179, (byte) 119, (byte) 65, (byte) 1, (byte) 25, - (byte) 53, (byte) 138, (byte) 120, (byte) 64, (byte) 1, (byte) 6, (byte) 183, - (byte) 247, (byte) 129, (byte) 64, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x16, payload); - MsgTrackingStateDepA msg = new MsgTrackingStateDepA(sbp); + byte[] payload = new byte[] {(byte)1,(byte)0,(byte)216,(byte)57,(byte)48,(byte)65,(byte)1,(byte)2,(byte)145,(byte)41,(byte)46,(byte)65,(byte)1,(byte)3,(byte)4,(byte)26,(byte)34,(byte)65,(byte)1,(byte)7,(byte)177,(byte)67,(byte)109,(byte)65,(byte)1,(byte)10,(byte)61,(byte)80,(byte)249,(byte)64,(byte)1,(byte)13,(byte)250,(byte)199,(byte)155,(byte)64,(byte)1,(byte)22,(byte)55,(byte)19,(byte)215,(byte)64,(byte)1,(byte)30,(byte)138,(byte)138,(byte)79,(byte)65,(byte)1,(byte)31,(byte)214,(byte)179,(byte)119,(byte)65,(byte)1,(byte)25,(byte)53,(byte)138,(byte)120,(byte)64,(byte)1,(byte)6,(byte)183,(byte)247,(byte)129,(byte)64, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x16, payload ); + MsgTrackingStateDepA msg = new MsgTrackingStateDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.states[0].cn0, 1.10141220092773438e+01, DELTA); value = msg.states[0].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -318,9 +252,7 @@ public void test2() throws Throwable { } value = msg.states[0].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[0].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -329,9 +261,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[1].cn0, 1.08851480484008789e+01, DELTA); value = msg.states[1].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].prn + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.states[1].prn + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -339,9 +269,7 @@ public void test2() throws Throwable { } value = msg.states[1].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[1].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -350,9 +278,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[2].cn0, 1.01313514709472656e+01, DELTA); value = msg.states[2].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].prn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[2].prn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -360,9 +286,7 @@ public void test2() throws Throwable { } value = msg.states[2].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[2].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -371,9 +295,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[3].cn0, 1.48290262222290039e+01, DELTA); value = msg.states[3].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].prn + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.states[3].prn + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -381,9 +303,7 @@ public void test2() throws Throwable { } value = msg.states[3].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[3].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -392,9 +312,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[4].cn0, 7.79104471206665039e+00, DELTA); value = msg.states[4].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].prn + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.states[4].prn + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -402,9 +320,7 @@ public void test2() throws Throwable { } value = msg.states[4].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[4].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -413,9 +329,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[5].cn0, 4.86816120147705078e+00, DELTA); value = msg.states[5].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].prn + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.states[5].prn + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -423,9 +337,7 @@ public void test2() throws Throwable { } value = msg.states[5].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[5].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -434,9 +346,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[6].cn0, 6.72109556198120117e+00, DELTA); value = msg.states[6].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].prn + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.states[6].prn + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -444,9 +354,7 @@ public void test2() throws Throwable { } value = msg.states[6].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[6].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -455,9 +363,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[7].cn0, 1.29713230133056641e+01, DELTA); value = msg.states[7].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].prn + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.states[7].prn + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -465,9 +371,7 @@ public void test2() throws Throwable { } value = msg.states[7].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[7].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -476,9 +380,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[8].cn0, 1.54814052581787109e+01, DELTA); value = msg.states[8].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].prn + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.states[8].prn + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -486,9 +388,7 @@ public void test2() throws Throwable { } value = msg.states[8].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[8].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -497,9 +397,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[9].cn0, 3.88343548774719238e+00, DELTA); value = msg.states[9].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].prn + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.states[9].prn + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -507,9 +405,7 @@ public void test2() throws Throwable { } value = msg.states[9].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[9].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -518,9 +414,7 @@ public void test2() throws Throwable { org.junit.Assert.assertEquals(msg.states[10].cn0, 4.06148862838745117e+00, DELTA); value = msg.states[10].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].prn + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.states[10].prn + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -528,9 +422,7 @@ public void test2() throws Throwable { } value = msg.states[10].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[10].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -544,30 +436,16 @@ public void test2() throws Throwable { public void test3() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgtrackingStateDepATest.test3"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 0, (byte) 141, (byte) 76, (byte) 60, (byte) 65, (byte) 1, - (byte) 2, (byte) 69, (byte) 139, (byte) 46, (byte) 65, (byte) 1, (byte) 3, - (byte) 146, (byte) 27, (byte) 30, (byte) 65, (byte) 1, (byte) 7, (byte) 235, - (byte) 56, (byte) 97, (byte) 65, (byte) 1, (byte) 10, (byte) 141, (byte) 213, - (byte) 243, (byte) 64, (byte) 1, (byte) 13, (byte) 250, (byte) 170, (byte) 166, - (byte) 64, (byte) 1, (byte) 22, (byte) 17, (byte) 101, (byte) 201, (byte) 64, - (byte) 1, (byte) 30, (byte) 172, (byte) 183, (byte) 83, (byte) 65, (byte) 1, - (byte) 31, (byte) 238, (byte) 193, (byte) 120, (byte) 65, (byte) 1, (byte) 25, - (byte) 220, (byte) 48, (byte) 132, (byte) 64, (byte) 1, (byte) 6, (byte) 49, - (byte) 214, (byte) 54, (byte) 64, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x16, payload); - MsgTrackingStateDepA msg = new MsgTrackingStateDepA(sbp); + byte[] payload = new byte[] {(byte)1,(byte)0,(byte)141,(byte)76,(byte)60,(byte)65,(byte)1,(byte)2,(byte)69,(byte)139,(byte)46,(byte)65,(byte)1,(byte)3,(byte)146,(byte)27,(byte)30,(byte)65,(byte)1,(byte)7,(byte)235,(byte)56,(byte)97,(byte)65,(byte)1,(byte)10,(byte)141,(byte)213,(byte)243,(byte)64,(byte)1,(byte)13,(byte)250,(byte)170,(byte)166,(byte)64,(byte)1,(byte)22,(byte)17,(byte)101,(byte)201,(byte)64,(byte)1,(byte)30,(byte)172,(byte)183,(byte)83,(byte)65,(byte)1,(byte)31,(byte)238,(byte)193,(byte)120,(byte)65,(byte)1,(byte)25,(byte)220,(byte)48,(byte)132,(byte)64,(byte)1,(byte)6,(byte)49,(byte)214,(byte)54,(byte)64, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x16, payload ); + MsgTrackingStateDepA msg = new MsgTrackingStateDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.states[0].cn0, 1.17686891555786133e+01, DELTA); value = msg.states[0].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -575,9 +453,7 @@ public void test3() throws Throwable { } value = msg.states[0].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[0].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -586,9 +462,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[1].cn0, 1.09090013504028320e+01, DELTA); value = msg.states[1].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].prn + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.states[1].prn + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -596,9 +470,7 @@ public void test3() throws Throwable { } value = msg.states[1].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[1].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -607,9 +479,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[2].cn0, 9.88173103332519531e+00, DELTA); value = msg.states[2].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].prn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[2].prn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -617,9 +487,7 @@ public void test3() throws Throwable { } value = msg.states[2].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[2].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -628,9 +496,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[3].cn0, 1.40763959884643555e+01, DELTA); value = msg.states[3].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].prn + "' != '" + 7 + "'", - value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.states[3].prn + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; @@ -638,9 +504,7 @@ public void test3() throws Throwable { } value = msg.states[3].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[3].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -649,9 +513,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[4].cn0, 7.61981821060180664e+00, DELTA); value = msg.states[4].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].prn + "' != '" + 10 + "'", - value.equals(BigInteger.valueOf(10L))); + org.junit.Assert.assertTrue("'" + msg.states[4].prn + "' != '" + 10 + "'", value.equals(BigInteger.valueOf( 10L ) ) ); } else { value = value.longValue(); expected = 10L; @@ -659,9 +521,7 @@ public void test3() throws Throwable { } value = msg.states[4].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[4].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -670,9 +530,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[5].cn0, 5.20837116241455078e+00, DELTA); value = msg.states[5].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].prn + "' != '" + 13 + "'", - value.equals(BigInteger.valueOf(13L))); + org.junit.Assert.assertTrue("'" + msg.states[5].prn + "' != '" + 13 + "'", value.equals(BigInteger.valueOf( 13L ) ) ); } else { value = value.longValue(); expected = 13L; @@ -680,9 +538,7 @@ public void test3() throws Throwable { } value = msg.states[5].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[5].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -691,9 +547,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[6].cn0, 6.29358720779418945e+00, DELTA); value = msg.states[6].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].prn + "' != '" + 22 + "'", - value.equals(BigInteger.valueOf(22L))); + org.junit.Assert.assertTrue("'" + msg.states[6].prn + "' != '" + 22 + "'", value.equals(BigInteger.valueOf( 22L ) ) ); } else { value = value.longValue(); expected = 22L; @@ -701,9 +555,7 @@ public void test3() throws Throwable { } value = msg.states[6].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[6].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -712,9 +564,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[7].cn0, 1.32323417663574219e+01, DELTA); value = msg.states[7].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].prn + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.states[7].prn + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -722,9 +572,7 @@ public void test3() throws Throwable { } value = msg.states[7].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[7].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -733,9 +581,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[8].cn0, 1.55473461151123047e+01, DELTA); value = msg.states[8].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].prn + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.states[8].prn + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -743,9 +589,7 @@ public void test3() throws Throwable { } value = msg.states[8].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[8].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -754,9 +598,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[9].cn0, 4.13096427917480469e+00, DELTA); value = msg.states[9].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].prn + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.states[9].prn + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -764,9 +606,7 @@ public void test3() throws Throwable { } value = msg.states[9].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[9].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -775,9 +615,7 @@ public void test3() throws Throwable { org.junit.Assert.assertEquals(msg.states[10].cn0, 2.85682320594787598e+00, DELTA); value = msg.states[10].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].prn + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.states[10].prn + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -785,9 +623,7 @@ public void test3() throws Throwable { } value = msg.states[10].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[10].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -801,30 +637,16 @@ public void test3() throws Throwable { public void test4() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgtrackingStateDepATest.test4"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 0, (byte) 55, (byte) 143, (byte) 120, (byte) 66, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 128, (byte) 191, (byte) 0, (byte) 0, (byte) 0, (byte) 0, - (byte) 128, (byte) 191, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, - (byte) 191, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 128, (byte) 191, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x16, payload); - MsgTrackingStateDepA msg = new MsgTrackingStateDepA(sbp); + byte[] payload = new byte[] {(byte)1,(byte)0,(byte)55,(byte)143,(byte)120,(byte)66,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x16, payload ); + MsgTrackingStateDepA msg = new MsgTrackingStateDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.states[0].cn0, 6.21398582458496094e+01, DELTA); value = msg.states[0].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -832,9 +654,7 @@ public void test4() throws Throwable { } value = msg.states[0].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[0].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -843,9 +663,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[1].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[1].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -853,9 +671,7 @@ public void test4() throws Throwable { } value = msg.states[1].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[1].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -864,9 +680,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[2].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[2].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -874,9 +688,7 @@ public void test4() throws Throwable { } value = msg.states[2].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[2].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -885,9 +697,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[3].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[3].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -895,9 +705,7 @@ public void test4() throws Throwable { } value = msg.states[3].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -906,9 +714,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[4].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[4].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -916,9 +722,7 @@ public void test4() throws Throwable { } value = msg.states[4].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -927,9 +731,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[5].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[5].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -937,9 +739,7 @@ public void test4() throws Throwable { } value = msg.states[5].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -948,9 +748,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[6].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[6].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -958,9 +756,7 @@ public void test4() throws Throwable { } value = msg.states[6].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -969,9 +765,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[7].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[7].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -979,9 +773,7 @@ public void test4() throws Throwable { } value = msg.states[7].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -990,9 +782,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[8].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[8].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1000,9 +790,7 @@ public void test4() throws Throwable { } value = msg.states[8].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1011,9 +799,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[9].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[9].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1021,9 +807,7 @@ public void test4() throws Throwable { } value = msg.states[9].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1032,9 +816,7 @@ public void test4() throws Throwable { org.junit.Assert.assertEquals(msg.states[10].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[10].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1042,9 +824,7 @@ public void test4() throws Throwable { } value = msg.states[10].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1058,30 +838,16 @@ public void test4() throws Throwable { public void test5() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgtrackingStateDepATest.test5"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 0, (byte) 218, (byte) 14, (byte) 19, (byte) 66, (byte) 1, - (byte) 2, (byte) 210, (byte) 3, (byte) 21, (byte) 65, (byte) 1, (byte) 3, - (byte) 234, (byte) 214, (byte) 134, (byte) 65, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 128, (byte) 191, (byte) 0, (byte) 0, (byte) 0, (byte) 0, - (byte) 128, (byte) 191, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, - (byte) 191, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 128, (byte) 191, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x16, payload); - MsgTrackingStateDepA msg = new MsgTrackingStateDepA(sbp); + byte[] payload = new byte[] {(byte)1,(byte)0,(byte)218,(byte)14,(byte)19,(byte)66,(byte)1,(byte)2,(byte)210,(byte)3,(byte)21,(byte)65,(byte)1,(byte)3,(byte)234,(byte)214,(byte)134,(byte)65,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x16, payload ); + MsgTrackingStateDepA msg = new MsgTrackingStateDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.states[0].cn0, 3.67645034790039062e+01, DELTA); value = msg.states[0].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1089,9 +855,7 @@ public void test5() throws Throwable { } value = msg.states[0].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[0].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1100,9 +864,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[1].cn0, 9.31343269348144531e+00, DELTA); value = msg.states[1].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].prn + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.states[1].prn + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1110,9 +872,7 @@ public void test5() throws Throwable { } value = msg.states[1].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[1].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1121,9 +881,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[2].cn0, 1.68549385070800781e+01, DELTA); value = msg.states[2].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].prn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[2].prn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1131,9 +889,7 @@ public void test5() throws Throwable { } value = msg.states[2].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[2].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1142,9 +898,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[3].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[3].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1152,9 +906,7 @@ public void test5() throws Throwable { } value = msg.states[3].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1163,9 +915,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[4].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[4].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1173,9 +923,7 @@ public void test5() throws Throwable { } value = msg.states[4].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1184,9 +932,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[5].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[5].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1194,9 +940,7 @@ public void test5() throws Throwable { } value = msg.states[5].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1205,9 +949,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[6].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[6].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1215,9 +957,7 @@ public void test5() throws Throwable { } value = msg.states[6].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1226,9 +966,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[7].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[7].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1236,9 +974,7 @@ public void test5() throws Throwable { } value = msg.states[7].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1247,9 +983,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[8].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[8].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1257,9 +991,7 @@ public void test5() throws Throwable { } value = msg.states[8].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1268,9 +1000,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[9].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[9].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1278,9 +1008,7 @@ public void test5() throws Throwable { } value = msg.states[9].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1289,9 +1017,7 @@ public void test5() throws Throwable { org.junit.Assert.assertEquals(msg.states[10].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[10].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1299,9 +1025,7 @@ public void test5() throws Throwable { } value = msg.states[10].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1315,30 +1039,16 @@ public void test5() throws Throwable { public void test6() throws Throwable { if (debug) System.out.format("%n%s%n", "auto_check_sbp_tracking_MsgtrackingStateDepATest.test6"); - byte[] payload = - new byte[] { - (byte) 1, (byte) 0, (byte) 98, (byte) 39, (byte) 219, (byte) 65, (byte) 1, - (byte) 2, (byte) 0, (byte) 0, (byte) 56, (byte) 64, (byte) 1, (byte) 3, - (byte) 121, (byte) 123, (byte) 7, (byte) 65, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 128, (byte) 191, (byte) 0, (byte) 0, (byte) 0, (byte) 0, - (byte) 128, (byte) 191, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, - (byte) 191, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, - (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, - (byte) 0, (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, (byte) 0, - (byte) 0, (byte) 0, (byte) 128, (byte) 191, (byte) 0, (byte) 0, (byte) 0, - (byte) 0, (byte) 128, (byte) 191, - }; - SBPMessage sbp = new SBPMessage(0x4c3, 0x16, payload); - MsgTrackingStateDepA msg = new MsgTrackingStateDepA(sbp); + byte[] payload = new byte[] {(byte)1,(byte)0,(byte)98,(byte)39,(byte)219,(byte)65,(byte)1,(byte)2,(byte)0,(byte)0,(byte)56,(byte)64,(byte)1,(byte)3,(byte)121,(byte)123,(byte)7,(byte)65,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191,(byte)0,(byte)0,(byte)0,(byte)0,(byte)128,(byte)191, }; + SBPMessage sbp = new SBPMessage( 0x4c3, 0x16, payload ); + MsgTrackingStateDepA msg = new MsgTrackingStateDepA( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; org.junit.Assert.assertEquals(msg.states[0].cn0, 2.73942298889160156e+01, DELTA); value = msg.states[0].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[0].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1346,9 +1056,7 @@ public void test6() throws Throwable { } value = msg.states[0].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[0].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[0].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1357,9 +1065,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[1].cn0, 2.87500000000000000e+00, DELTA); value = msg.states[1].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].prn + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.states[1].prn + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1367,9 +1073,7 @@ public void test6() throws Throwable { } value = msg.states[1].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[1].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[1].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1378,9 +1082,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[2].cn0, 8.46764469146728516e+00, DELTA); value = msg.states[2].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].prn + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.states[2].prn + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -1388,9 +1090,7 @@ public void test6() throws Throwable { } value = msg.states[2].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[2].state + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.states[2].state + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -1399,9 +1099,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[3].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[3].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1409,9 +1107,7 @@ public void test6() throws Throwable { } value = msg.states[3].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[3].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[3].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1420,9 +1116,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[4].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[4].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1430,9 +1124,7 @@ public void test6() throws Throwable { } value = msg.states[4].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[4].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[4].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1441,9 +1133,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[5].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[5].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1451,9 +1141,7 @@ public void test6() throws Throwable { } value = msg.states[5].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[5].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[5].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1462,9 +1150,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[6].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[6].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1472,9 +1158,7 @@ public void test6() throws Throwable { } value = msg.states[6].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[6].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[6].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1483,9 +1167,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[7].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[7].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1493,9 +1175,7 @@ public void test6() throws Throwable { } value = msg.states[7].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[7].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[7].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1504,9 +1184,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[8].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[8].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1514,9 +1192,7 @@ public void test6() throws Throwable { } value = msg.states[8].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[8].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[8].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1525,9 +1201,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[9].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[9].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1535,9 +1209,7 @@ public void test6() throws Throwable { } value = msg.states[9].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[9].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[9].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1546,9 +1218,7 @@ public void test6() throws Throwable { org.junit.Assert.assertEquals(msg.states[10].cn0, -1.00000000000000000e+00, DELTA); value = msg.states[10].prn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].prn + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].prn + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1556,9 +1226,7 @@ public void test6() throws Throwable { } value = msg.states[10].state; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.states[10].state + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.states[10].state + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; diff --git a/java/test/auto_check_sbp_tracking_tracking_structsTest.java b/java/test/auto_check_sbp_tracking_tracking_structsTest.java index 882019dd1..a90969bc8 100644 --- a/java/test/auto_check_sbp_tracking_tracking_structsTest.java +++ b/java/test/auto_check_sbp_tracking_tracking_structsTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,11 +9,19 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from -// spec/tests/yaml/swiftnav/sbp/tracking/test_tracking_structs.yaml by generate.py. Do not modify by -// hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/tracking/test_tracking_structs.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; + +import org.json.JSONObject; + +import com.swiftnav.sbp.SBPMessage; + public class auto_check_sbp_tracking_tracking_structsTest { diff --git a/java/test/auto_check_sbp_user_MsgUserDataTest.java b/java/test/auto_check_sbp_user_MsgUserDataTest.java index c2320a329..66abba75a 100644 --- a/java/test/auto_check_sbp_user_MsgUserDataTest.java +++ b/java/test/auto_check_sbp_user_MsgUserDataTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/user/test_MsgUserData.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/user/test_MsgUserData.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.user.MsgUserData; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_user_MsgUserDataTest { @@ -27,275 +32,17 @@ public class auto_check_sbp_user_MsgUserDataTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_user_MsgUserDataTest.test1"); - byte[] payload = - new byte[] { - (byte) 53, - (byte) 5, - (byte) 172, - (byte) 138, - (byte) 50, - (byte) 49, - (byte) 206, - (byte) 234, - (byte) 149, - (byte) 204, - (byte) 113, - (byte) 31, - (byte) 108, - (byte) 188, - (byte) 179, - (byte) 154, - (byte) 156, - (byte) 167, - (byte) 145, - (byte) 139, - (byte) 42, - (byte) 207, - (byte) 126, - (byte) 242, - (byte) 193, - (byte) 9, - (byte) 58, - (byte) 75, - (byte) 8, - (byte) 135, - (byte) 11, - (byte) 92, - (byte) 131, - (byte) 245, - (byte) 24, - (byte) 90, - (byte) 255, - (byte) 30, - (byte) 58, - (byte) 31, - (byte) 109, - (byte) 148, - (byte) 56, - (byte) 178, - (byte) 140, - (byte) 30, - (byte) 159, - (byte) 70, - (byte) 17, - (byte) 170, - (byte) 50, - (byte) 148, - (byte) 1, - (byte) 99, - (byte) 112, - (byte) 88, - (byte) 217, - (byte) 36, - (byte) 84, - (byte) 34, - (byte) 234, - (byte) 82, - (byte) 144, - (byte) 144, - (byte) 97, - (byte) 96, - (byte) 75, - (byte) 174, - (byte) 58, - (byte) 219, - (byte) 180, - (byte) 148, - (byte) 247, - (byte) 59, - (byte) 2, - (byte) 116, - (byte) 214, - (byte) 114, - (byte) 55, - (byte) 134, - (byte) 54, - (byte) 119, - (byte) 108, - (byte) 128, - (byte) 73, - (byte) 181, - (byte) 20, - (byte) 233, - (byte) 23, - (byte) 23, - (byte) 73, - (byte) 119, - (byte) 136, - (byte) 231, - (byte) 189, - (byte) 26, - (byte) 174, - (byte) 128, - (byte) 93, - (byte) 30, - (byte) 76, - (byte) 45, - (byte) 109, - (byte) 134, - (byte) 81, - (byte) 0, - (byte) 116, - (byte) 158, - (byte) 127, - (byte) 40, - (byte) 133, - (byte) 208, - (byte) 134, - (byte) 127, - (byte) 140, - (byte) 232, - (byte) 183, - (byte) 184, - (byte) 108, - (byte) 6, - (byte) 228, - (byte) 54, - (byte) 238, - (byte) 59, - (byte) 220, - (byte) 30, - (byte) 228, - (byte) 212, - (byte) 50, - (byte) 182, - (byte) 97, - (byte) 20, - (byte) 41, - (byte) 76, - (byte) 227, - (byte) 88, - (byte) 12, - (byte) 95, - (byte) 112, - (byte) 209, - (byte) 183, - (byte) 127, - (byte) 4, - (byte) 165, - (byte) 189, - (byte) 44, - (byte) 239, - (byte) 232, - (byte) 132, - (byte) 9, - (byte) 114, - (byte) 184, - (byte) 249, - (byte) 208, - (byte) 246, - (byte) 194, - (byte) 250, - (byte) 2, - (byte) 97, - (byte) 173, - (byte) 157, - (byte) 202, - (byte) 172, - (byte) 180, - (byte) 150, - (byte) 213, - (byte) 193, - (byte) 177, - (byte) 209, - (byte) 156, - (byte) 20, - (byte) 174, - (byte) 18, - (byte) 73, - (byte) 132, - (byte) 215, - (byte) 115, - (byte) 128, - (byte) 175, - (byte) 169, - (byte) 116, - (byte) 132, - (byte) 100, - (byte) 72, - (byte) 45, - (byte) 25, - (byte) 14, - (byte) 205, - (byte) 213, - (byte) 145, - (byte) 68, - (byte) 137, - (byte) 249, - (byte) 54, - (byte) 40, - (byte) 174, - (byte) 215, - (byte) 148, - (byte) 166, - (byte) 190, - (byte) 63, - (byte) 118, - (byte) 6, - (byte) 165, - (byte) 212, - (byte) 74, - (byte) 68, - (byte) 200, - (byte) 38, - (byte) 139, - (byte) 212, - (byte) 112, - (byte) 45, - (byte) 167, - (byte) 236, - (byte) 255, - (byte) 106, - (byte) 92, - (byte) 132, - (byte) 59, - (byte) 61, - (byte) 233, - (byte) 3, - (byte) 246, - (byte) 158, - (byte) 83, - (byte) 134, - (byte) 246, - (byte) 154, - (byte) 17, - (byte) 0, - (byte) 6, - (byte) 56, - (byte) 216, - (byte) 19, - (byte) 216, - (byte) 70, - (byte) 71, - (byte) 161, - (byte) 184, - (byte) 5, - (byte) 177, - (byte) 45, - (byte) 37, - (byte) 98, - (byte) 56, - (byte) 149, - (byte) 0, - (byte) 73, - (byte) 221, - (byte) 105, - (byte) 239, - (byte) 168, - (byte) 205, - (byte) 85, - }; - SBPMessage sbp = new SBPMessage(0x217e, 0x800, payload); - MsgUserData msg = new MsgUserData(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_user_MsgUserDataTest.test1"); + byte[] payload = new byte[] {(byte)53,(byte)5,(byte)172,(byte)138,(byte)50,(byte)49,(byte)206,(byte)234,(byte)149,(byte)204,(byte)113,(byte)31,(byte)108,(byte)188,(byte)179,(byte)154,(byte)156,(byte)167,(byte)145,(byte)139,(byte)42,(byte)207,(byte)126,(byte)242,(byte)193,(byte)9,(byte)58,(byte)75,(byte)8,(byte)135,(byte)11,(byte)92,(byte)131,(byte)245,(byte)24,(byte)90,(byte)255,(byte)30,(byte)58,(byte)31,(byte)109,(byte)148,(byte)56,(byte)178,(byte)140,(byte)30,(byte)159,(byte)70,(byte)17,(byte)170,(byte)50,(byte)148,(byte)1,(byte)99,(byte)112,(byte)88,(byte)217,(byte)36,(byte)84,(byte)34,(byte)234,(byte)82,(byte)144,(byte)144,(byte)97,(byte)96,(byte)75,(byte)174,(byte)58,(byte)219,(byte)180,(byte)148,(byte)247,(byte)59,(byte)2,(byte)116,(byte)214,(byte)114,(byte)55,(byte)134,(byte)54,(byte)119,(byte)108,(byte)128,(byte)73,(byte)181,(byte)20,(byte)233,(byte)23,(byte)23,(byte)73,(byte)119,(byte)136,(byte)231,(byte)189,(byte)26,(byte)174,(byte)128,(byte)93,(byte)30,(byte)76,(byte)45,(byte)109,(byte)134,(byte)81,(byte)0,(byte)116,(byte)158,(byte)127,(byte)40,(byte)133,(byte)208,(byte)134,(byte)127,(byte)140,(byte)232,(byte)183,(byte)184,(byte)108,(byte)6,(byte)228,(byte)54,(byte)238,(byte)59,(byte)220,(byte)30,(byte)228,(byte)212,(byte)50,(byte)182,(byte)97,(byte)20,(byte)41,(byte)76,(byte)227,(byte)88,(byte)12,(byte)95,(byte)112,(byte)209,(byte)183,(byte)127,(byte)4,(byte)165,(byte)189,(byte)44,(byte)239,(byte)232,(byte)132,(byte)9,(byte)114,(byte)184,(byte)249,(byte)208,(byte)246,(byte)194,(byte)250,(byte)2,(byte)97,(byte)173,(byte)157,(byte)202,(byte)172,(byte)180,(byte)150,(byte)213,(byte)193,(byte)177,(byte)209,(byte)156,(byte)20,(byte)174,(byte)18,(byte)73,(byte)132,(byte)215,(byte)115,(byte)128,(byte)175,(byte)169,(byte)116,(byte)132,(byte)100,(byte)72,(byte)45,(byte)25,(byte)14,(byte)205,(byte)213,(byte)145,(byte)68,(byte)137,(byte)249,(byte)54,(byte)40,(byte)174,(byte)215,(byte)148,(byte)166,(byte)190,(byte)63,(byte)118,(byte)6,(byte)165,(byte)212,(byte)74,(byte)68,(byte)200,(byte)38,(byte)139,(byte)212,(byte)112,(byte)45,(byte)167,(byte)236,(byte)255,(byte)106,(byte)92,(byte)132,(byte)59,(byte)61,(byte)233,(byte)3,(byte)246,(byte)158,(byte)83,(byte)134,(byte)246,(byte)154,(byte)17,(byte)0,(byte)6,(byte)56,(byte)216,(byte)19,(byte)216,(byte)70,(byte)71,(byte)161,(byte)184,(byte)5,(byte)177,(byte)45,(byte)37,(byte)98,(byte)56,(byte)149,(byte)0,(byte)73,(byte)221,(byte)105,(byte)239,(byte)168,(byte)205,(byte)85, }; + SBPMessage sbp = new SBPMessage( 0x217e, 0x800, payload ); + MsgUserData msg = new MsgUserData( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.contents[0]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[0] + "' != '" + 53 + "'", - value.equals(BigInteger.valueOf(53L))); + org.junit.Assert.assertTrue("'" + msg.contents[0] + "' != '" + 53 + "'", value.equals(BigInteger.valueOf( 53L ) ) ); } else { value = value.longValue(); expected = 53L; @@ -303,9 +50,7 @@ public void test1() throws Throwable { } value = msg.contents[1]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[1] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.contents[1] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -313,9 +58,7 @@ public void test1() throws Throwable { } value = msg.contents[2]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[2] + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.contents[2] + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -323,9 +66,7 @@ public void test1() throws Throwable { } value = msg.contents[3]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[3] + "' != '" + 138 + "'", - value.equals(BigInteger.valueOf(138L))); + org.junit.Assert.assertTrue("'" + msg.contents[3] + "' != '" + 138 + "'", value.equals(BigInteger.valueOf( 138L ) ) ); } else { value = value.longValue(); expected = 138L; @@ -333,9 +74,7 @@ public void test1() throws Throwable { } value = msg.contents[4]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[4] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.contents[4] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -343,9 +82,7 @@ public void test1() throws Throwable { } value = msg.contents[5]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[5] + "' != '" + 49 + "'", - value.equals(BigInteger.valueOf(49L))); + org.junit.Assert.assertTrue("'" + msg.contents[5] + "' != '" + 49 + "'", value.equals(BigInteger.valueOf( 49L ) ) ); } else { value = value.longValue(); expected = 49L; @@ -353,9 +90,7 @@ public void test1() throws Throwable { } value = msg.contents[6]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[6] + "' != '" + 206 + "'", - value.equals(BigInteger.valueOf(206L))); + org.junit.Assert.assertTrue("'" + msg.contents[6] + "' != '" + 206 + "'", value.equals(BigInteger.valueOf( 206L ) ) ); } else { value = value.longValue(); expected = 206L; @@ -363,9 +98,7 @@ public void test1() throws Throwable { } value = msg.contents[7]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[7] + "' != '" + 234 + "'", - value.equals(BigInteger.valueOf(234L))); + org.junit.Assert.assertTrue("'" + msg.contents[7] + "' != '" + 234 + "'", value.equals(BigInteger.valueOf( 234L ) ) ); } else { value = value.longValue(); expected = 234L; @@ -373,9 +106,7 @@ public void test1() throws Throwable { } value = msg.contents[8]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[8] + "' != '" + 149 + "'", - value.equals(BigInteger.valueOf(149L))); + org.junit.Assert.assertTrue("'" + msg.contents[8] + "' != '" + 149 + "'", value.equals(BigInteger.valueOf( 149L ) ) ); } else { value = value.longValue(); expected = 149L; @@ -383,9 +114,7 @@ public void test1() throws Throwable { } value = msg.contents[9]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[9] + "' != '" + 204 + "'", - value.equals(BigInteger.valueOf(204L))); + org.junit.Assert.assertTrue("'" + msg.contents[9] + "' != '" + 204 + "'", value.equals(BigInteger.valueOf( 204L ) ) ); } else { value = value.longValue(); expected = 204L; @@ -393,9 +122,7 @@ public void test1() throws Throwable { } value = msg.contents[10]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[10] + "' != '" + 113 + "'", - value.equals(BigInteger.valueOf(113L))); + org.junit.Assert.assertTrue("'" + msg.contents[10] + "' != '" + 113 + "'", value.equals(BigInteger.valueOf( 113L ) ) ); } else { value = value.longValue(); expected = 113L; @@ -403,9 +130,7 @@ public void test1() throws Throwable { } value = msg.contents[11]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[11] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.contents[11] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -413,9 +138,7 @@ public void test1() throws Throwable { } value = msg.contents[12]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[12] + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.contents[12] + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -423,9 +146,7 @@ public void test1() throws Throwable { } value = msg.contents[13]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[13] + "' != '" + 188 + "'", - value.equals(BigInteger.valueOf(188L))); + org.junit.Assert.assertTrue("'" + msg.contents[13] + "' != '" + 188 + "'", value.equals(BigInteger.valueOf( 188L ) ) ); } else { value = value.longValue(); expected = 188L; @@ -433,9 +154,7 @@ public void test1() throws Throwable { } value = msg.contents[14]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[14] + "' != '" + 179 + "'", - value.equals(BigInteger.valueOf(179L))); + org.junit.Assert.assertTrue("'" + msg.contents[14] + "' != '" + 179 + "'", value.equals(BigInteger.valueOf( 179L ) ) ); } else { value = value.longValue(); expected = 179L; @@ -443,9 +162,7 @@ public void test1() throws Throwable { } value = msg.contents[15]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[15] + "' != '" + 154 + "'", - value.equals(BigInteger.valueOf(154L))); + org.junit.Assert.assertTrue("'" + msg.contents[15] + "' != '" + 154 + "'", value.equals(BigInteger.valueOf( 154L ) ) ); } else { value = value.longValue(); expected = 154L; @@ -453,9 +170,7 @@ public void test1() throws Throwable { } value = msg.contents[16]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[16] + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.contents[16] + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -463,9 +178,7 @@ public void test1() throws Throwable { } value = msg.contents[17]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[17] + "' != '" + 167 + "'", - value.equals(BigInteger.valueOf(167L))); + org.junit.Assert.assertTrue("'" + msg.contents[17] + "' != '" + 167 + "'", value.equals(BigInteger.valueOf( 167L ) ) ); } else { value = value.longValue(); expected = 167L; @@ -473,9 +186,7 @@ public void test1() throws Throwable { } value = msg.contents[18]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[18] + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.contents[18] + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -483,9 +194,7 @@ public void test1() throws Throwable { } value = msg.contents[19]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[19] + "' != '" + 139 + "'", - value.equals(BigInteger.valueOf(139L))); + org.junit.Assert.assertTrue("'" + msg.contents[19] + "' != '" + 139 + "'", value.equals(BigInteger.valueOf( 139L ) ) ); } else { value = value.longValue(); expected = 139L; @@ -493,9 +202,7 @@ public void test1() throws Throwable { } value = msg.contents[20]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[20] + "' != '" + 42 + "'", - value.equals(BigInteger.valueOf(42L))); + org.junit.Assert.assertTrue("'" + msg.contents[20] + "' != '" + 42 + "'", value.equals(BigInteger.valueOf( 42L ) ) ); } else { value = value.longValue(); expected = 42L; @@ -503,9 +210,7 @@ public void test1() throws Throwable { } value = msg.contents[21]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[21] + "' != '" + 207 + "'", - value.equals(BigInteger.valueOf(207L))); + org.junit.Assert.assertTrue("'" + msg.contents[21] + "' != '" + 207 + "'", value.equals(BigInteger.valueOf( 207L ) ) ); } else { value = value.longValue(); expected = 207L; @@ -513,9 +218,7 @@ public void test1() throws Throwable { } value = msg.contents[22]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[22] + "' != '" + 126 + "'", - value.equals(BigInteger.valueOf(126L))); + org.junit.Assert.assertTrue("'" + msg.contents[22] + "' != '" + 126 + "'", value.equals(BigInteger.valueOf( 126L ) ) ); } else { value = value.longValue(); expected = 126L; @@ -523,9 +226,7 @@ public void test1() throws Throwable { } value = msg.contents[23]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[23] + "' != '" + 242 + "'", - value.equals(BigInteger.valueOf(242L))); + org.junit.Assert.assertTrue("'" + msg.contents[23] + "' != '" + 242 + "'", value.equals(BigInteger.valueOf( 242L ) ) ); } else { value = value.longValue(); expected = 242L; @@ -533,9 +234,7 @@ public void test1() throws Throwable { } value = msg.contents[24]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[24] + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.contents[24] + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -543,9 +242,7 @@ public void test1() throws Throwable { } value = msg.contents[25]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[25] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.contents[25] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -553,9 +250,7 @@ public void test1() throws Throwable { } value = msg.contents[26]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[26] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.contents[26] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -563,9 +258,7 @@ public void test1() throws Throwable { } value = msg.contents[27]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[27] + "' != '" + 75 + "'", - value.equals(BigInteger.valueOf(75L))); + org.junit.Assert.assertTrue("'" + msg.contents[27] + "' != '" + 75 + "'", value.equals(BigInteger.valueOf( 75L ) ) ); } else { value = value.longValue(); expected = 75L; @@ -573,9 +266,7 @@ public void test1() throws Throwable { } value = msg.contents[28]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[28] + "' != '" + 8 + "'", - value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.contents[28] + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -583,9 +274,7 @@ public void test1() throws Throwable { } value = msg.contents[29]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[29] + "' != '" + 135 + "'", - value.equals(BigInteger.valueOf(135L))); + org.junit.Assert.assertTrue("'" + msg.contents[29] + "' != '" + 135 + "'", value.equals(BigInteger.valueOf( 135L ) ) ); } else { value = value.longValue(); expected = 135L; @@ -593,9 +282,7 @@ public void test1() throws Throwable { } value = msg.contents[30]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[30] + "' != '" + 11 + "'", - value.equals(BigInteger.valueOf(11L))); + org.junit.Assert.assertTrue("'" + msg.contents[30] + "' != '" + 11 + "'", value.equals(BigInteger.valueOf( 11L ) ) ); } else { value = value.longValue(); expected = 11L; @@ -603,9 +290,7 @@ public void test1() throws Throwable { } value = msg.contents[31]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[31] + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.contents[31] + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -613,9 +298,7 @@ public void test1() throws Throwable { } value = msg.contents[32]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[32] + "' != '" + 131 + "'", - value.equals(BigInteger.valueOf(131L))); + org.junit.Assert.assertTrue("'" + msg.contents[32] + "' != '" + 131 + "'", value.equals(BigInteger.valueOf( 131L ) ) ); } else { value = value.longValue(); expected = 131L; @@ -623,9 +306,7 @@ public void test1() throws Throwable { } value = msg.contents[33]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[33] + "' != '" + 245 + "'", - value.equals(BigInteger.valueOf(245L))); + org.junit.Assert.assertTrue("'" + msg.contents[33] + "' != '" + 245 + "'", value.equals(BigInteger.valueOf( 245L ) ) ); } else { value = value.longValue(); expected = 245L; @@ -633,9 +314,7 @@ public void test1() throws Throwable { } value = msg.contents[34]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[34] + "' != '" + 24 + "'", - value.equals(BigInteger.valueOf(24L))); + org.junit.Assert.assertTrue("'" + msg.contents[34] + "' != '" + 24 + "'", value.equals(BigInteger.valueOf( 24L ) ) ); } else { value = value.longValue(); expected = 24L; @@ -643,9 +322,7 @@ public void test1() throws Throwable { } value = msg.contents[35]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[35] + "' != '" + 90 + "'", - value.equals(BigInteger.valueOf(90L))); + org.junit.Assert.assertTrue("'" + msg.contents[35] + "' != '" + 90 + "'", value.equals(BigInteger.valueOf( 90L ) ) ); } else { value = value.longValue(); expected = 90L; @@ -653,9 +330,7 @@ public void test1() throws Throwable { } value = msg.contents[36]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[36] + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.contents[36] + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -663,9 +338,7 @@ public void test1() throws Throwable { } value = msg.contents[37]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[37] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.contents[37] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -673,9 +346,7 @@ public void test1() throws Throwable { } value = msg.contents[38]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[38] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.contents[38] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -683,9 +354,7 @@ public void test1() throws Throwable { } value = msg.contents[39]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[39] + "' != '" + 31 + "'", - value.equals(BigInteger.valueOf(31L))); + org.junit.Assert.assertTrue("'" + msg.contents[39] + "' != '" + 31 + "'", value.equals(BigInteger.valueOf( 31L ) ) ); } else { value = value.longValue(); expected = 31L; @@ -693,9 +362,7 @@ public void test1() throws Throwable { } value = msg.contents[40]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[40] + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.contents[40] + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -703,9 +370,7 @@ public void test1() throws Throwable { } value = msg.contents[41]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[41] + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.contents[41] + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -713,9 +378,7 @@ public void test1() throws Throwable { } value = msg.contents[42]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[42] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.contents[42] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -723,9 +386,7 @@ public void test1() throws Throwable { } value = msg.contents[43]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[43] + "' != '" + 178 + "'", - value.equals(BigInteger.valueOf(178L))); + org.junit.Assert.assertTrue("'" + msg.contents[43] + "' != '" + 178 + "'", value.equals(BigInteger.valueOf( 178L ) ) ); } else { value = value.longValue(); expected = 178L; @@ -733,9 +394,7 @@ public void test1() throws Throwable { } value = msg.contents[44]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[44] + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.contents[44] + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -743,9 +402,7 @@ public void test1() throws Throwable { } value = msg.contents[45]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[45] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.contents[45] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -753,9 +410,7 @@ public void test1() throws Throwable { } value = msg.contents[46]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[46] + "' != '" + 159 + "'", - value.equals(BigInteger.valueOf(159L))); + org.junit.Assert.assertTrue("'" + msg.contents[46] + "' != '" + 159 + "'", value.equals(BigInteger.valueOf( 159L ) ) ); } else { value = value.longValue(); expected = 159L; @@ -763,9 +418,7 @@ public void test1() throws Throwable { } value = msg.contents[47]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[47] + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.contents[47] + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -773,9 +426,7 @@ public void test1() throws Throwable { } value = msg.contents[48]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[48] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.contents[48] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -783,9 +434,7 @@ public void test1() throws Throwable { } value = msg.contents[49]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[49] + "' != '" + 170 + "'", - value.equals(BigInteger.valueOf(170L))); + org.junit.Assert.assertTrue("'" + msg.contents[49] + "' != '" + 170 + "'", value.equals(BigInteger.valueOf( 170L ) ) ); } else { value = value.longValue(); expected = 170L; @@ -793,9 +442,7 @@ public void test1() throws Throwable { } value = msg.contents[50]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[50] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.contents[50] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -803,9 +450,7 @@ public void test1() throws Throwable { } value = msg.contents[51]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[51] + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.contents[51] + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -813,9 +458,7 @@ public void test1() throws Throwable { } value = msg.contents[52]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[52] + "' != '" + 1 + "'", - value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.contents[52] + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -823,9 +466,7 @@ public void test1() throws Throwable { } value = msg.contents[53]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[53] + "' != '" + 99 + "'", - value.equals(BigInteger.valueOf(99L))); + org.junit.Assert.assertTrue("'" + msg.contents[53] + "' != '" + 99 + "'", value.equals(BigInteger.valueOf( 99L ) ) ); } else { value = value.longValue(); expected = 99L; @@ -833,9 +474,7 @@ public void test1() throws Throwable { } value = msg.contents[54]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[54] + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.contents[54] + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -843,9 +482,7 @@ public void test1() throws Throwable { } value = msg.contents[55]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[55] + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.contents[55] + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -853,9 +490,7 @@ public void test1() throws Throwable { } value = msg.contents[56]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[56] + "' != '" + 217 + "'", - value.equals(BigInteger.valueOf(217L))); + org.junit.Assert.assertTrue("'" + msg.contents[56] + "' != '" + 217 + "'", value.equals(BigInteger.valueOf( 217L ) ) ); } else { value = value.longValue(); expected = 217L; @@ -863,9 +498,7 @@ public void test1() throws Throwable { } value = msg.contents[57]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[57] + "' != '" + 36 + "'", - value.equals(BigInteger.valueOf(36L))); + org.junit.Assert.assertTrue("'" + msg.contents[57] + "' != '" + 36 + "'", value.equals(BigInteger.valueOf( 36L ) ) ); } else { value = value.longValue(); expected = 36L; @@ -873,9 +506,7 @@ public void test1() throws Throwable { } value = msg.contents[58]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[58] + "' != '" + 84 + "'", - value.equals(BigInteger.valueOf(84L))); + org.junit.Assert.assertTrue("'" + msg.contents[58] + "' != '" + 84 + "'", value.equals(BigInteger.valueOf( 84L ) ) ); } else { value = value.longValue(); expected = 84L; @@ -883,9 +514,7 @@ public void test1() throws Throwable { } value = msg.contents[59]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[59] + "' != '" + 34 + "'", - value.equals(BigInteger.valueOf(34L))); + org.junit.Assert.assertTrue("'" + msg.contents[59] + "' != '" + 34 + "'", value.equals(BigInteger.valueOf( 34L ) ) ); } else { value = value.longValue(); expected = 34L; @@ -893,9 +522,7 @@ public void test1() throws Throwable { } value = msg.contents[60]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[60] + "' != '" + 234 + "'", - value.equals(BigInteger.valueOf(234L))); + org.junit.Assert.assertTrue("'" + msg.contents[60] + "' != '" + 234 + "'", value.equals(BigInteger.valueOf( 234L ) ) ); } else { value = value.longValue(); expected = 234L; @@ -903,9 +530,7 @@ public void test1() throws Throwable { } value = msg.contents[61]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[61] + "' != '" + 82 + "'", - value.equals(BigInteger.valueOf(82L))); + org.junit.Assert.assertTrue("'" + msg.contents[61] + "' != '" + 82 + "'", value.equals(BigInteger.valueOf( 82L ) ) ); } else { value = value.longValue(); expected = 82L; @@ -913,9 +538,7 @@ public void test1() throws Throwable { } value = msg.contents[62]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[62] + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.contents[62] + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -923,9 +546,7 @@ public void test1() throws Throwable { } value = msg.contents[63]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[63] + "' != '" + 144 + "'", - value.equals(BigInteger.valueOf(144L))); + org.junit.Assert.assertTrue("'" + msg.contents[63] + "' != '" + 144 + "'", value.equals(BigInteger.valueOf( 144L ) ) ); } else { value = value.longValue(); expected = 144L; @@ -933,9 +554,7 @@ public void test1() throws Throwable { } value = msg.contents[64]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[64] + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.contents[64] + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -943,9 +562,7 @@ public void test1() throws Throwable { } value = msg.contents[65]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[65] + "' != '" + 96 + "'", - value.equals(BigInteger.valueOf(96L))); + org.junit.Assert.assertTrue("'" + msg.contents[65] + "' != '" + 96 + "'", value.equals(BigInteger.valueOf( 96L ) ) ); } else { value = value.longValue(); expected = 96L; @@ -953,9 +570,7 @@ public void test1() throws Throwable { } value = msg.contents[66]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[66] + "' != '" + 75 + "'", - value.equals(BigInteger.valueOf(75L))); + org.junit.Assert.assertTrue("'" + msg.contents[66] + "' != '" + 75 + "'", value.equals(BigInteger.valueOf( 75L ) ) ); } else { value = value.longValue(); expected = 75L; @@ -963,9 +578,7 @@ public void test1() throws Throwable { } value = msg.contents[67]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[67] + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.contents[67] + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -973,9 +586,7 @@ public void test1() throws Throwable { } value = msg.contents[68]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[68] + "' != '" + 58 + "'", - value.equals(BigInteger.valueOf(58L))); + org.junit.Assert.assertTrue("'" + msg.contents[68] + "' != '" + 58 + "'", value.equals(BigInteger.valueOf( 58L ) ) ); } else { value = value.longValue(); expected = 58L; @@ -983,9 +594,7 @@ public void test1() throws Throwable { } value = msg.contents[69]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[69] + "' != '" + 219 + "'", - value.equals(BigInteger.valueOf(219L))); + org.junit.Assert.assertTrue("'" + msg.contents[69] + "' != '" + 219 + "'", value.equals(BigInteger.valueOf( 219L ) ) ); } else { value = value.longValue(); expected = 219L; @@ -993,9 +602,7 @@ public void test1() throws Throwable { } value = msg.contents[70]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[70] + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.contents[70] + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -1003,9 +610,7 @@ public void test1() throws Throwable { } value = msg.contents[71]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[71] + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.contents[71] + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -1013,9 +618,7 @@ public void test1() throws Throwable { } value = msg.contents[72]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[72] + "' != '" + 247 + "'", - value.equals(BigInteger.valueOf(247L))); + org.junit.Assert.assertTrue("'" + msg.contents[72] + "' != '" + 247 + "'", value.equals(BigInteger.valueOf( 247L ) ) ); } else { value = value.longValue(); expected = 247L; @@ -1023,9 +626,7 @@ public void test1() throws Throwable { } value = msg.contents[73]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[73] + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.contents[73] + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -1033,9 +634,7 @@ public void test1() throws Throwable { } value = msg.contents[74]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[74] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.contents[74] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1043,9 +642,7 @@ public void test1() throws Throwable { } value = msg.contents[75]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[75] + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.contents[75] + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1053,9 +650,7 @@ public void test1() throws Throwable { } value = msg.contents[76]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[76] + "' != '" + 214 + "'", - value.equals(BigInteger.valueOf(214L))); + org.junit.Assert.assertTrue("'" + msg.contents[76] + "' != '" + 214 + "'", value.equals(BigInteger.valueOf( 214L ) ) ); } else { value = value.longValue(); expected = 214L; @@ -1063,9 +658,7 @@ public void test1() throws Throwable { } value = msg.contents[77]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[77] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.contents[77] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -1073,9 +666,7 @@ public void test1() throws Throwable { } value = msg.contents[78]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[78] + "' != '" + 55 + "'", - value.equals(BigInteger.valueOf(55L))); + org.junit.Assert.assertTrue("'" + msg.contents[78] + "' != '" + 55 + "'", value.equals(BigInteger.valueOf( 55L ) ) ); } else { value = value.longValue(); expected = 55L; @@ -1083,9 +674,7 @@ public void test1() throws Throwable { } value = msg.contents[79]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[79] + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.contents[79] + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -1093,9 +682,7 @@ public void test1() throws Throwable { } value = msg.contents[80]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[80] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.contents[80] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -1103,9 +690,7 @@ public void test1() throws Throwable { } value = msg.contents[81]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[81] + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.contents[81] + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -1113,9 +698,7 @@ public void test1() throws Throwable { } value = msg.contents[82]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[82] + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.contents[82] + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -1123,9 +706,7 @@ public void test1() throws Throwable { } value = msg.contents[83]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[83] + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.contents[83] + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -1133,9 +714,7 @@ public void test1() throws Throwable { } value = msg.contents[84]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[84] + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.contents[84] + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -1143,9 +722,7 @@ public void test1() throws Throwable { } value = msg.contents[85]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[85] + "' != '" + 181 + "'", - value.equals(BigInteger.valueOf(181L))); + org.junit.Assert.assertTrue("'" + msg.contents[85] + "' != '" + 181 + "'", value.equals(BigInteger.valueOf( 181L ) ) ); } else { value = value.longValue(); expected = 181L; @@ -1153,9 +730,7 @@ public void test1() throws Throwable { } value = msg.contents[86]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[86] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.contents[86] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -1163,9 +738,7 @@ public void test1() throws Throwable { } value = msg.contents[87]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[87] + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.contents[87] + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -1173,9 +746,7 @@ public void test1() throws Throwable { } value = msg.contents[88]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[88] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.contents[88] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1183,9 +754,7 @@ public void test1() throws Throwable { } value = msg.contents[89]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[89] + "' != '" + 23 + "'", - value.equals(BigInteger.valueOf(23L))); + org.junit.Assert.assertTrue("'" + msg.contents[89] + "' != '" + 23 + "'", value.equals(BigInteger.valueOf( 23L ) ) ); } else { value = value.longValue(); expected = 23L; @@ -1193,9 +762,7 @@ public void test1() throws Throwable { } value = msg.contents[90]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[90] + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.contents[90] + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -1203,9 +770,7 @@ public void test1() throws Throwable { } value = msg.contents[91]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[91] + "' != '" + 119 + "'", - value.equals(BigInteger.valueOf(119L))); + org.junit.Assert.assertTrue("'" + msg.contents[91] + "' != '" + 119 + "'", value.equals(BigInteger.valueOf( 119L ) ) ); } else { value = value.longValue(); expected = 119L; @@ -1213,9 +778,7 @@ public void test1() throws Throwable { } value = msg.contents[92]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[92] + "' != '" + 136 + "'", - value.equals(BigInteger.valueOf(136L))); + org.junit.Assert.assertTrue("'" + msg.contents[92] + "' != '" + 136 + "'", value.equals(BigInteger.valueOf( 136L ) ) ); } else { value = value.longValue(); expected = 136L; @@ -1223,9 +786,7 @@ public void test1() throws Throwable { } value = msg.contents[93]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[93] + "' != '" + 231 + "'", - value.equals(BigInteger.valueOf(231L))); + org.junit.Assert.assertTrue("'" + msg.contents[93] + "' != '" + 231 + "'", value.equals(BigInteger.valueOf( 231L ) ) ); } else { value = value.longValue(); expected = 231L; @@ -1233,9 +794,7 @@ public void test1() throws Throwable { } value = msg.contents[94]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[94] + "' != '" + 189 + "'", - value.equals(BigInteger.valueOf(189L))); + org.junit.Assert.assertTrue("'" + msg.contents[94] + "' != '" + 189 + "'", value.equals(BigInteger.valueOf( 189L ) ) ); } else { value = value.longValue(); expected = 189L; @@ -1243,9 +802,7 @@ public void test1() throws Throwable { } value = msg.contents[95]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[95] + "' != '" + 26 + "'", - value.equals(BigInteger.valueOf(26L))); + org.junit.Assert.assertTrue("'" + msg.contents[95] + "' != '" + 26 + "'", value.equals(BigInteger.valueOf( 26L ) ) ); } else { value = value.longValue(); expected = 26L; @@ -1253,9 +810,7 @@ public void test1() throws Throwable { } value = msg.contents[96]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[96] + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.contents[96] + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -1263,9 +818,7 @@ public void test1() throws Throwable { } value = msg.contents[97]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[97] + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.contents[97] + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -1273,9 +826,7 @@ public void test1() throws Throwable { } value = msg.contents[98]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[98] + "' != '" + 93 + "'", - value.equals(BigInteger.valueOf(93L))); + org.junit.Assert.assertTrue("'" + msg.contents[98] + "' != '" + 93 + "'", value.equals(BigInteger.valueOf( 93L ) ) ); } else { value = value.longValue(); expected = 93L; @@ -1283,9 +834,7 @@ public void test1() throws Throwable { } value = msg.contents[99]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[99] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.contents[99] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -1293,9 +842,7 @@ public void test1() throws Throwable { } value = msg.contents[100]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[100] + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.contents[100] + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -1303,9 +850,7 @@ public void test1() throws Throwable { } value = msg.contents[101]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[101] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.contents[101] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -1313,9 +858,7 @@ public void test1() throws Throwable { } value = msg.contents[102]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[102] + "' != '" + 109 + "'", - value.equals(BigInteger.valueOf(109L))); + org.junit.Assert.assertTrue("'" + msg.contents[102] + "' != '" + 109 + "'", value.equals(BigInteger.valueOf( 109L ) ) ); } else { value = value.longValue(); expected = 109L; @@ -1323,9 +866,7 @@ public void test1() throws Throwable { } value = msg.contents[103]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[103] + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.contents[103] + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -1333,9 +874,7 @@ public void test1() throws Throwable { } value = msg.contents[104]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[104] + "' != '" + 81 + "'", - value.equals(BigInteger.valueOf(81L))); + org.junit.Assert.assertTrue("'" + msg.contents[104] + "' != '" + 81 + "'", value.equals(BigInteger.valueOf( 81L ) ) ); } else { value = value.longValue(); expected = 81L; @@ -1343,9 +882,7 @@ public void test1() throws Throwable { } value = msg.contents[105]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[105] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.contents[105] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -1353,9 +890,7 @@ public void test1() throws Throwable { } value = msg.contents[106]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[106] + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.contents[106] + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -1363,9 +898,7 @@ public void test1() throws Throwable { } value = msg.contents[107]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[107] + "' != '" + 158 + "'", - value.equals(BigInteger.valueOf(158L))); + org.junit.Assert.assertTrue("'" + msg.contents[107] + "' != '" + 158 + "'", value.equals(BigInteger.valueOf( 158L ) ) ); } else { value = value.longValue(); expected = 158L; @@ -1373,9 +906,7 @@ public void test1() throws Throwable { } value = msg.contents[108]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[108] + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.contents[108] + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -1383,9 +914,7 @@ public void test1() throws Throwable { } value = msg.contents[109]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[109] + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.contents[109] + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -1393,9 +922,7 @@ public void test1() throws Throwable { } value = msg.contents[110]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[110] + "' != '" + 133 + "'", - value.equals(BigInteger.valueOf(133L))); + org.junit.Assert.assertTrue("'" + msg.contents[110] + "' != '" + 133 + "'", value.equals(BigInteger.valueOf( 133L ) ) ); } else { value = value.longValue(); expected = 133L; @@ -1403,9 +930,7 @@ public void test1() throws Throwable { } value = msg.contents[111]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[111] + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.contents[111] + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -1413,9 +938,7 @@ public void test1() throws Throwable { } value = msg.contents[112]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[112] + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.contents[112] + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -1423,9 +946,7 @@ public void test1() throws Throwable { } value = msg.contents[113]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[113] + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.contents[113] + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -1433,9 +954,7 @@ public void test1() throws Throwable { } value = msg.contents[114]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[114] + "' != '" + 140 + "'", - value.equals(BigInteger.valueOf(140L))); + org.junit.Assert.assertTrue("'" + msg.contents[114] + "' != '" + 140 + "'", value.equals(BigInteger.valueOf( 140L ) ) ); } else { value = value.longValue(); expected = 140L; @@ -1443,9 +962,7 @@ public void test1() throws Throwable { } value = msg.contents[115]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[115] + "' != '" + 232 + "'", - value.equals(BigInteger.valueOf(232L))); + org.junit.Assert.assertTrue("'" + msg.contents[115] + "' != '" + 232 + "'", value.equals(BigInteger.valueOf( 232L ) ) ); } else { value = value.longValue(); expected = 232L; @@ -1453,9 +970,7 @@ public void test1() throws Throwable { } value = msg.contents[116]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[116] + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.contents[116] + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -1463,9 +978,7 @@ public void test1() throws Throwable { } value = msg.contents[117]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[117] + "' != '" + 184 + "'", - value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.contents[117] + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -1473,9 +986,7 @@ public void test1() throws Throwable { } value = msg.contents[118]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[118] + "' != '" + 108 + "'", - value.equals(BigInteger.valueOf(108L))); + org.junit.Assert.assertTrue("'" + msg.contents[118] + "' != '" + 108 + "'", value.equals(BigInteger.valueOf( 108L ) ) ); } else { value = value.longValue(); expected = 108L; @@ -1483,9 +994,7 @@ public void test1() throws Throwable { } value = msg.contents[119]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[119] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.contents[119] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -1493,9 +1002,7 @@ public void test1() throws Throwable { } value = msg.contents[120]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[120] + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.contents[120] + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -1503,9 +1010,7 @@ public void test1() throws Throwable { } value = msg.contents[121]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[121] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.contents[121] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -1513,9 +1018,7 @@ public void test1() throws Throwable { } value = msg.contents[122]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[122] + "' != '" + 238 + "'", - value.equals(BigInteger.valueOf(238L))); + org.junit.Assert.assertTrue("'" + msg.contents[122] + "' != '" + 238 + "'", value.equals(BigInteger.valueOf( 238L ) ) ); } else { value = value.longValue(); expected = 238L; @@ -1523,9 +1026,7 @@ public void test1() throws Throwable { } value = msg.contents[123]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[123] + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.contents[123] + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -1533,9 +1034,7 @@ public void test1() throws Throwable { } value = msg.contents[124]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[124] + "' != '" + 220 + "'", - value.equals(BigInteger.valueOf(220L))); + org.junit.Assert.assertTrue("'" + msg.contents[124] + "' != '" + 220 + "'", value.equals(BigInteger.valueOf( 220L ) ) ); } else { value = value.longValue(); expected = 220L; @@ -1543,9 +1042,7 @@ public void test1() throws Throwable { } value = msg.contents[125]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[125] + "' != '" + 30 + "'", - value.equals(BigInteger.valueOf(30L))); + org.junit.Assert.assertTrue("'" + msg.contents[125] + "' != '" + 30 + "'", value.equals(BigInteger.valueOf( 30L ) ) ); } else { value = value.longValue(); expected = 30L; @@ -1553,9 +1050,7 @@ public void test1() throws Throwable { } value = msg.contents[126]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[126] + "' != '" + 228 + "'", - value.equals(BigInteger.valueOf(228L))); + org.junit.Assert.assertTrue("'" + msg.contents[126] + "' != '" + 228 + "'", value.equals(BigInteger.valueOf( 228L ) ) ); } else { value = value.longValue(); expected = 228L; @@ -1563,9 +1058,7 @@ public void test1() throws Throwable { } value = msg.contents[127]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[127] + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.contents[127] + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -1573,9 +1066,7 @@ public void test1() throws Throwable { } value = msg.contents[128]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[128] + "' != '" + 50 + "'", - value.equals(BigInteger.valueOf(50L))); + org.junit.Assert.assertTrue("'" + msg.contents[128] + "' != '" + 50 + "'", value.equals(BigInteger.valueOf( 50L ) ) ); } else { value = value.longValue(); expected = 50L; @@ -1583,9 +1074,7 @@ public void test1() throws Throwable { } value = msg.contents[129]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[129] + "' != '" + 182 + "'", - value.equals(BigInteger.valueOf(182L))); + org.junit.Assert.assertTrue("'" + msg.contents[129] + "' != '" + 182 + "'", value.equals(BigInteger.valueOf( 182L ) ) ); } else { value = value.longValue(); expected = 182L; @@ -1593,9 +1082,7 @@ public void test1() throws Throwable { } value = msg.contents[130]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[130] + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.contents[130] + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -1603,9 +1090,7 @@ public void test1() throws Throwable { } value = msg.contents[131]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[131] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.contents[131] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -1613,9 +1098,7 @@ public void test1() throws Throwable { } value = msg.contents[132]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[132] + "' != '" + 41 + "'", - value.equals(BigInteger.valueOf(41L))); + org.junit.Assert.assertTrue("'" + msg.contents[132] + "' != '" + 41 + "'", value.equals(BigInteger.valueOf( 41L ) ) ); } else { value = value.longValue(); expected = 41L; @@ -1623,9 +1106,7 @@ public void test1() throws Throwable { } value = msg.contents[133]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[133] + "' != '" + 76 + "'", - value.equals(BigInteger.valueOf(76L))); + org.junit.Assert.assertTrue("'" + msg.contents[133] + "' != '" + 76 + "'", value.equals(BigInteger.valueOf( 76L ) ) ); } else { value = value.longValue(); expected = 76L; @@ -1633,9 +1114,7 @@ public void test1() throws Throwable { } value = msg.contents[134]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[134] + "' != '" + 227 + "'", - value.equals(BigInteger.valueOf(227L))); + org.junit.Assert.assertTrue("'" + msg.contents[134] + "' != '" + 227 + "'", value.equals(BigInteger.valueOf( 227L ) ) ); } else { value = value.longValue(); expected = 227L; @@ -1643,9 +1122,7 @@ public void test1() throws Throwable { } value = msg.contents[135]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[135] + "' != '" + 88 + "'", - value.equals(BigInteger.valueOf(88L))); + org.junit.Assert.assertTrue("'" + msg.contents[135] + "' != '" + 88 + "'", value.equals(BigInteger.valueOf( 88L ) ) ); } else { value = value.longValue(); expected = 88L; @@ -1653,9 +1130,7 @@ public void test1() throws Throwable { } value = msg.contents[136]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[136] + "' != '" + 12 + "'", - value.equals(BigInteger.valueOf(12L))); + org.junit.Assert.assertTrue("'" + msg.contents[136] + "' != '" + 12 + "'", value.equals(BigInteger.valueOf( 12L ) ) ); } else { value = value.longValue(); expected = 12L; @@ -1663,9 +1138,7 @@ public void test1() throws Throwable { } value = msg.contents[137]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[137] + "' != '" + 95 + "'", - value.equals(BigInteger.valueOf(95L))); + org.junit.Assert.assertTrue("'" + msg.contents[137] + "' != '" + 95 + "'", value.equals(BigInteger.valueOf( 95L ) ) ); } else { value = value.longValue(); expected = 95L; @@ -1673,9 +1146,7 @@ public void test1() throws Throwable { } value = msg.contents[138]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[138] + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.contents[138] + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -1683,9 +1154,7 @@ public void test1() throws Throwable { } value = msg.contents[139]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[139] + "' != '" + 209 + "'", - value.equals(BigInteger.valueOf(209L))); + org.junit.Assert.assertTrue("'" + msg.contents[139] + "' != '" + 209 + "'", value.equals(BigInteger.valueOf( 209L ) ) ); } else { value = value.longValue(); expected = 209L; @@ -1693,9 +1162,7 @@ public void test1() throws Throwable { } value = msg.contents[140]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[140] + "' != '" + 183 + "'", - value.equals(BigInteger.valueOf(183L))); + org.junit.Assert.assertTrue("'" + msg.contents[140] + "' != '" + 183 + "'", value.equals(BigInteger.valueOf( 183L ) ) ); } else { value = value.longValue(); expected = 183L; @@ -1703,9 +1170,7 @@ public void test1() throws Throwable { } value = msg.contents[141]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[141] + "' != '" + 127 + "'", - value.equals(BigInteger.valueOf(127L))); + org.junit.Assert.assertTrue("'" + msg.contents[141] + "' != '" + 127 + "'", value.equals(BigInteger.valueOf( 127L ) ) ); } else { value = value.longValue(); expected = 127L; @@ -1713,9 +1178,7 @@ public void test1() throws Throwable { } value = msg.contents[142]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[142] + "' != '" + 4 + "'", - value.equals(BigInteger.valueOf(4L))); + org.junit.Assert.assertTrue("'" + msg.contents[142] + "' != '" + 4 + "'", value.equals(BigInteger.valueOf( 4L ) ) ); } else { value = value.longValue(); expected = 4L; @@ -1723,9 +1186,7 @@ public void test1() throws Throwable { } value = msg.contents[143]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[143] + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.contents[143] + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -1733,9 +1194,7 @@ public void test1() throws Throwable { } value = msg.contents[144]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[144] + "' != '" + 189 + "'", - value.equals(BigInteger.valueOf(189L))); + org.junit.Assert.assertTrue("'" + msg.contents[144] + "' != '" + 189 + "'", value.equals(BigInteger.valueOf( 189L ) ) ); } else { value = value.longValue(); expected = 189L; @@ -1743,9 +1202,7 @@ public void test1() throws Throwable { } value = msg.contents[145]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[145] + "' != '" + 44 + "'", - value.equals(BigInteger.valueOf(44L))); + org.junit.Assert.assertTrue("'" + msg.contents[145] + "' != '" + 44 + "'", value.equals(BigInteger.valueOf( 44L ) ) ); } else { value = value.longValue(); expected = 44L; @@ -1753,9 +1210,7 @@ public void test1() throws Throwable { } value = msg.contents[146]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[146] + "' != '" + 239 + "'", - value.equals(BigInteger.valueOf(239L))); + org.junit.Assert.assertTrue("'" + msg.contents[146] + "' != '" + 239 + "'", value.equals(BigInteger.valueOf( 239L ) ) ); } else { value = value.longValue(); expected = 239L; @@ -1763,9 +1218,7 @@ public void test1() throws Throwable { } value = msg.contents[147]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[147] + "' != '" + 232 + "'", - value.equals(BigInteger.valueOf(232L))); + org.junit.Assert.assertTrue("'" + msg.contents[147] + "' != '" + 232 + "'", value.equals(BigInteger.valueOf( 232L ) ) ); } else { value = value.longValue(); expected = 232L; @@ -1773,9 +1226,7 @@ public void test1() throws Throwable { } value = msg.contents[148]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[148] + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.contents[148] + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -1783,9 +1234,7 @@ public void test1() throws Throwable { } value = msg.contents[149]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[149] + "' != '" + 9 + "'", - value.equals(BigInteger.valueOf(9L))); + org.junit.Assert.assertTrue("'" + msg.contents[149] + "' != '" + 9 + "'", value.equals(BigInteger.valueOf( 9L ) ) ); } else { value = value.longValue(); expected = 9L; @@ -1793,9 +1242,7 @@ public void test1() throws Throwable { } value = msg.contents[150]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[150] + "' != '" + 114 + "'", - value.equals(BigInteger.valueOf(114L))); + org.junit.Assert.assertTrue("'" + msg.contents[150] + "' != '" + 114 + "'", value.equals(BigInteger.valueOf( 114L ) ) ); } else { value = value.longValue(); expected = 114L; @@ -1803,9 +1250,7 @@ public void test1() throws Throwable { } value = msg.contents[151]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[151] + "' != '" + 184 + "'", - value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.contents[151] + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -1813,9 +1258,7 @@ public void test1() throws Throwable { } value = msg.contents[152]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[152] + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.contents[152] + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -1823,9 +1266,7 @@ public void test1() throws Throwable { } value = msg.contents[153]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[153] + "' != '" + 208 + "'", - value.equals(BigInteger.valueOf(208L))); + org.junit.Assert.assertTrue("'" + msg.contents[153] + "' != '" + 208 + "'", value.equals(BigInteger.valueOf( 208L ) ) ); } else { value = value.longValue(); expected = 208L; @@ -1833,9 +1274,7 @@ public void test1() throws Throwable { } value = msg.contents[154]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[154] + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.contents[154] + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -1843,9 +1282,7 @@ public void test1() throws Throwable { } value = msg.contents[155]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[155] + "' != '" + 194 + "'", - value.equals(BigInteger.valueOf(194L))); + org.junit.Assert.assertTrue("'" + msg.contents[155] + "' != '" + 194 + "'", value.equals(BigInteger.valueOf( 194L ) ) ); } else { value = value.longValue(); expected = 194L; @@ -1853,9 +1290,7 @@ public void test1() throws Throwable { } value = msg.contents[156]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[156] + "' != '" + 250 + "'", - value.equals(BigInteger.valueOf(250L))); + org.junit.Assert.assertTrue("'" + msg.contents[156] + "' != '" + 250 + "'", value.equals(BigInteger.valueOf( 250L ) ) ); } else { value = value.longValue(); expected = 250L; @@ -1863,9 +1298,7 @@ public void test1() throws Throwable { } value = msg.contents[157]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[157] + "' != '" + 2 + "'", - value.equals(BigInteger.valueOf(2L))); + org.junit.Assert.assertTrue("'" + msg.contents[157] + "' != '" + 2 + "'", value.equals(BigInteger.valueOf( 2L ) ) ); } else { value = value.longValue(); expected = 2L; @@ -1873,9 +1306,7 @@ public void test1() throws Throwable { } value = msg.contents[158]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[158] + "' != '" + 97 + "'", - value.equals(BigInteger.valueOf(97L))); + org.junit.Assert.assertTrue("'" + msg.contents[158] + "' != '" + 97 + "'", value.equals(BigInteger.valueOf( 97L ) ) ); } else { value = value.longValue(); expected = 97L; @@ -1883,9 +1314,7 @@ public void test1() throws Throwable { } value = msg.contents[159]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[159] + "' != '" + 173 + "'", - value.equals(BigInteger.valueOf(173L))); + org.junit.Assert.assertTrue("'" + msg.contents[159] + "' != '" + 173 + "'", value.equals(BigInteger.valueOf( 173L ) ) ); } else { value = value.longValue(); expected = 173L; @@ -1893,9 +1322,7 @@ public void test1() throws Throwable { } value = msg.contents[160]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[160] + "' != '" + 157 + "'", - value.equals(BigInteger.valueOf(157L))); + org.junit.Assert.assertTrue("'" + msg.contents[160] + "' != '" + 157 + "'", value.equals(BigInteger.valueOf( 157L ) ) ); } else { value = value.longValue(); expected = 157L; @@ -1903,9 +1330,7 @@ public void test1() throws Throwable { } value = msg.contents[161]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[161] + "' != '" + 202 + "'", - value.equals(BigInteger.valueOf(202L))); + org.junit.Assert.assertTrue("'" + msg.contents[161] + "' != '" + 202 + "'", value.equals(BigInteger.valueOf( 202L ) ) ); } else { value = value.longValue(); expected = 202L; @@ -1913,9 +1338,7 @@ public void test1() throws Throwable { } value = msg.contents[162]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[162] + "' != '" + 172 + "'", - value.equals(BigInteger.valueOf(172L))); + org.junit.Assert.assertTrue("'" + msg.contents[162] + "' != '" + 172 + "'", value.equals(BigInteger.valueOf( 172L ) ) ); } else { value = value.longValue(); expected = 172L; @@ -1923,9 +1346,7 @@ public void test1() throws Throwable { } value = msg.contents[163]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[163] + "' != '" + 180 + "'", - value.equals(BigInteger.valueOf(180L))); + org.junit.Assert.assertTrue("'" + msg.contents[163] + "' != '" + 180 + "'", value.equals(BigInteger.valueOf( 180L ) ) ); } else { value = value.longValue(); expected = 180L; @@ -1933,9 +1354,7 @@ public void test1() throws Throwable { } value = msg.contents[164]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[164] + "' != '" + 150 + "'", - value.equals(BigInteger.valueOf(150L))); + org.junit.Assert.assertTrue("'" + msg.contents[164] + "' != '" + 150 + "'", value.equals(BigInteger.valueOf( 150L ) ) ); } else { value = value.longValue(); expected = 150L; @@ -1943,9 +1362,7 @@ public void test1() throws Throwable { } value = msg.contents[165]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[165] + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.contents[165] + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -1953,9 +1370,7 @@ public void test1() throws Throwable { } value = msg.contents[166]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[166] + "' != '" + 193 + "'", - value.equals(BigInteger.valueOf(193L))); + org.junit.Assert.assertTrue("'" + msg.contents[166] + "' != '" + 193 + "'", value.equals(BigInteger.valueOf( 193L ) ) ); } else { value = value.longValue(); expected = 193L; @@ -1963,9 +1378,7 @@ public void test1() throws Throwable { } value = msg.contents[167]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[167] + "' != '" + 177 + "'", - value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.contents[167] + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -1973,9 +1386,7 @@ public void test1() throws Throwable { } value = msg.contents[168]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[168] + "' != '" + 209 + "'", - value.equals(BigInteger.valueOf(209L))); + org.junit.Assert.assertTrue("'" + msg.contents[168] + "' != '" + 209 + "'", value.equals(BigInteger.valueOf( 209L ) ) ); } else { value = value.longValue(); expected = 209L; @@ -1983,9 +1394,7 @@ public void test1() throws Throwable { } value = msg.contents[169]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[169] + "' != '" + 156 + "'", - value.equals(BigInteger.valueOf(156L))); + org.junit.Assert.assertTrue("'" + msg.contents[169] + "' != '" + 156 + "'", value.equals(BigInteger.valueOf( 156L ) ) ); } else { value = value.longValue(); expected = 156L; @@ -1993,9 +1402,7 @@ public void test1() throws Throwable { } value = msg.contents[170]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[170] + "' != '" + 20 + "'", - value.equals(BigInteger.valueOf(20L))); + org.junit.Assert.assertTrue("'" + msg.contents[170] + "' != '" + 20 + "'", value.equals(BigInteger.valueOf( 20L ) ) ); } else { value = value.longValue(); expected = 20L; @@ -2003,9 +1410,7 @@ public void test1() throws Throwable { } value = msg.contents[171]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[171] + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.contents[171] + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -2013,9 +1418,7 @@ public void test1() throws Throwable { } value = msg.contents[172]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[172] + "' != '" + 18 + "'", - value.equals(BigInteger.valueOf(18L))); + org.junit.Assert.assertTrue("'" + msg.contents[172] + "' != '" + 18 + "'", value.equals(BigInteger.valueOf( 18L ) ) ); } else { value = value.longValue(); expected = 18L; @@ -2023,9 +1426,7 @@ public void test1() throws Throwable { } value = msg.contents[173]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[173] + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.contents[173] + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -2033,9 +1434,7 @@ public void test1() throws Throwable { } value = msg.contents[174]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[174] + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.contents[174] + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -2043,9 +1442,7 @@ public void test1() throws Throwable { } value = msg.contents[175]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[175] + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.contents[175] + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -2053,9 +1450,7 @@ public void test1() throws Throwable { } value = msg.contents[176]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[176] + "' != '" + 115 + "'", - value.equals(BigInteger.valueOf(115L))); + org.junit.Assert.assertTrue("'" + msg.contents[176] + "' != '" + 115 + "'", value.equals(BigInteger.valueOf( 115L ) ) ); } else { value = value.longValue(); expected = 115L; @@ -2063,9 +1458,7 @@ public void test1() throws Throwable { } value = msg.contents[177]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[177] + "' != '" + 128 + "'", - value.equals(BigInteger.valueOf(128L))); + org.junit.Assert.assertTrue("'" + msg.contents[177] + "' != '" + 128 + "'", value.equals(BigInteger.valueOf( 128L ) ) ); } else { value = value.longValue(); expected = 128L; @@ -2073,9 +1466,7 @@ public void test1() throws Throwable { } value = msg.contents[178]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[178] + "' != '" + 175 + "'", - value.equals(BigInteger.valueOf(175L))); + org.junit.Assert.assertTrue("'" + msg.contents[178] + "' != '" + 175 + "'", value.equals(BigInteger.valueOf( 175L ) ) ); } else { value = value.longValue(); expected = 175L; @@ -2083,9 +1474,7 @@ public void test1() throws Throwable { } value = msg.contents[179]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[179] + "' != '" + 169 + "'", - value.equals(BigInteger.valueOf(169L))); + org.junit.Assert.assertTrue("'" + msg.contents[179] + "' != '" + 169 + "'", value.equals(BigInteger.valueOf( 169L ) ) ); } else { value = value.longValue(); expected = 169L; @@ -2093,9 +1482,7 @@ public void test1() throws Throwable { } value = msg.contents[180]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[180] + "' != '" + 116 + "'", - value.equals(BigInteger.valueOf(116L))); + org.junit.Assert.assertTrue("'" + msg.contents[180] + "' != '" + 116 + "'", value.equals(BigInteger.valueOf( 116L ) ) ); } else { value = value.longValue(); expected = 116L; @@ -2103,9 +1490,7 @@ public void test1() throws Throwable { } value = msg.contents[181]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[181] + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.contents[181] + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -2113,9 +1498,7 @@ public void test1() throws Throwable { } value = msg.contents[182]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[182] + "' != '" + 100 + "'", - value.equals(BigInteger.valueOf(100L))); + org.junit.Assert.assertTrue("'" + msg.contents[182] + "' != '" + 100 + "'", value.equals(BigInteger.valueOf( 100L ) ) ); } else { value = value.longValue(); expected = 100L; @@ -2123,9 +1506,7 @@ public void test1() throws Throwable { } value = msg.contents[183]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[183] + "' != '" + 72 + "'", - value.equals(BigInteger.valueOf(72L))); + org.junit.Assert.assertTrue("'" + msg.contents[183] + "' != '" + 72 + "'", value.equals(BigInteger.valueOf( 72L ) ) ); } else { value = value.longValue(); expected = 72L; @@ -2133,9 +1514,7 @@ public void test1() throws Throwable { } value = msg.contents[184]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[184] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.contents[184] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -2143,9 +1522,7 @@ public void test1() throws Throwable { } value = msg.contents[185]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[185] + "' != '" + 25 + "'", - value.equals(BigInteger.valueOf(25L))); + org.junit.Assert.assertTrue("'" + msg.contents[185] + "' != '" + 25 + "'", value.equals(BigInteger.valueOf( 25L ) ) ); } else { value = value.longValue(); expected = 25L; @@ -2153,9 +1530,7 @@ public void test1() throws Throwable { } value = msg.contents[186]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[186] + "' != '" + 14 + "'", - value.equals(BigInteger.valueOf(14L))); + org.junit.Assert.assertTrue("'" + msg.contents[186] + "' != '" + 14 + "'", value.equals(BigInteger.valueOf( 14L ) ) ); } else { value = value.longValue(); expected = 14L; @@ -2163,9 +1538,7 @@ public void test1() throws Throwable { } value = msg.contents[187]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[187] + "' != '" + 205 + "'", - value.equals(BigInteger.valueOf(205L))); + org.junit.Assert.assertTrue("'" + msg.contents[187] + "' != '" + 205 + "'", value.equals(BigInteger.valueOf( 205L ) ) ); } else { value = value.longValue(); expected = 205L; @@ -2173,9 +1546,7 @@ public void test1() throws Throwable { } value = msg.contents[188]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[188] + "' != '" + 213 + "'", - value.equals(BigInteger.valueOf(213L))); + org.junit.Assert.assertTrue("'" + msg.contents[188] + "' != '" + 213 + "'", value.equals(BigInteger.valueOf( 213L ) ) ); } else { value = value.longValue(); expected = 213L; @@ -2183,9 +1554,7 @@ public void test1() throws Throwable { } value = msg.contents[189]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[189] + "' != '" + 145 + "'", - value.equals(BigInteger.valueOf(145L))); + org.junit.Assert.assertTrue("'" + msg.contents[189] + "' != '" + 145 + "'", value.equals(BigInteger.valueOf( 145L ) ) ); } else { value = value.longValue(); expected = 145L; @@ -2193,9 +1562,7 @@ public void test1() throws Throwable { } value = msg.contents[190]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[190] + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.contents[190] + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -2203,9 +1570,7 @@ public void test1() throws Throwable { } value = msg.contents[191]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[191] + "' != '" + 137 + "'", - value.equals(BigInteger.valueOf(137L))); + org.junit.Assert.assertTrue("'" + msg.contents[191] + "' != '" + 137 + "'", value.equals(BigInteger.valueOf( 137L ) ) ); } else { value = value.longValue(); expected = 137L; @@ -2213,9 +1578,7 @@ public void test1() throws Throwable { } value = msg.contents[192]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[192] + "' != '" + 249 + "'", - value.equals(BigInteger.valueOf(249L))); + org.junit.Assert.assertTrue("'" + msg.contents[192] + "' != '" + 249 + "'", value.equals(BigInteger.valueOf( 249L ) ) ); } else { value = value.longValue(); expected = 249L; @@ -2223,9 +1586,7 @@ public void test1() throws Throwable { } value = msg.contents[193]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[193] + "' != '" + 54 + "'", - value.equals(BigInteger.valueOf(54L))); + org.junit.Assert.assertTrue("'" + msg.contents[193] + "' != '" + 54 + "'", value.equals(BigInteger.valueOf( 54L ) ) ); } else { value = value.longValue(); expected = 54L; @@ -2233,9 +1594,7 @@ public void test1() throws Throwable { } value = msg.contents[194]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[194] + "' != '" + 40 + "'", - value.equals(BigInteger.valueOf(40L))); + org.junit.Assert.assertTrue("'" + msg.contents[194] + "' != '" + 40 + "'", value.equals(BigInteger.valueOf( 40L ) ) ); } else { value = value.longValue(); expected = 40L; @@ -2243,9 +1602,7 @@ public void test1() throws Throwable { } value = msg.contents[195]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[195] + "' != '" + 174 + "'", - value.equals(BigInteger.valueOf(174L))); + org.junit.Assert.assertTrue("'" + msg.contents[195] + "' != '" + 174 + "'", value.equals(BigInteger.valueOf( 174L ) ) ); } else { value = value.longValue(); expected = 174L; @@ -2253,9 +1610,7 @@ public void test1() throws Throwable { } value = msg.contents[196]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[196] + "' != '" + 215 + "'", - value.equals(BigInteger.valueOf(215L))); + org.junit.Assert.assertTrue("'" + msg.contents[196] + "' != '" + 215 + "'", value.equals(BigInteger.valueOf( 215L ) ) ); } else { value = value.longValue(); expected = 215L; @@ -2263,9 +1618,7 @@ public void test1() throws Throwable { } value = msg.contents[197]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[197] + "' != '" + 148 + "'", - value.equals(BigInteger.valueOf(148L))); + org.junit.Assert.assertTrue("'" + msg.contents[197] + "' != '" + 148 + "'", value.equals(BigInteger.valueOf( 148L ) ) ); } else { value = value.longValue(); expected = 148L; @@ -2273,9 +1626,7 @@ public void test1() throws Throwable { } value = msg.contents[198]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[198] + "' != '" + 166 + "'", - value.equals(BigInteger.valueOf(166L))); + org.junit.Assert.assertTrue("'" + msg.contents[198] + "' != '" + 166 + "'", value.equals(BigInteger.valueOf( 166L ) ) ); } else { value = value.longValue(); expected = 166L; @@ -2283,9 +1634,7 @@ public void test1() throws Throwable { } value = msg.contents[199]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[199] + "' != '" + 190 + "'", - value.equals(BigInteger.valueOf(190L))); + org.junit.Assert.assertTrue("'" + msg.contents[199] + "' != '" + 190 + "'", value.equals(BigInteger.valueOf( 190L ) ) ); } else { value = value.longValue(); expected = 190L; @@ -2293,9 +1642,7 @@ public void test1() throws Throwable { } value = msg.contents[200]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[200] + "' != '" + 63 + "'", - value.equals(BigInteger.valueOf(63L))); + org.junit.Assert.assertTrue("'" + msg.contents[200] + "' != '" + 63 + "'", value.equals(BigInteger.valueOf( 63L ) ) ); } else { value = value.longValue(); expected = 63L; @@ -2303,9 +1650,7 @@ public void test1() throws Throwable { } value = msg.contents[201]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[201] + "' != '" + 118 + "'", - value.equals(BigInteger.valueOf(118L))); + org.junit.Assert.assertTrue("'" + msg.contents[201] + "' != '" + 118 + "'", value.equals(BigInteger.valueOf( 118L ) ) ); } else { value = value.longValue(); expected = 118L; @@ -2313,9 +1658,7 @@ public void test1() throws Throwable { } value = msg.contents[202]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[202] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.contents[202] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -2323,9 +1666,7 @@ public void test1() throws Throwable { } value = msg.contents[203]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[203] + "' != '" + 165 + "'", - value.equals(BigInteger.valueOf(165L))); + org.junit.Assert.assertTrue("'" + msg.contents[203] + "' != '" + 165 + "'", value.equals(BigInteger.valueOf( 165L ) ) ); } else { value = value.longValue(); expected = 165L; @@ -2333,9 +1674,7 @@ public void test1() throws Throwable { } value = msg.contents[204]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[204] + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.contents[204] + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -2343,9 +1682,7 @@ public void test1() throws Throwable { } value = msg.contents[205]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[205] + "' != '" + 74 + "'", - value.equals(BigInteger.valueOf(74L))); + org.junit.Assert.assertTrue("'" + msg.contents[205] + "' != '" + 74 + "'", value.equals(BigInteger.valueOf( 74L ) ) ); } else { value = value.longValue(); expected = 74L; @@ -2353,9 +1690,7 @@ public void test1() throws Throwable { } value = msg.contents[206]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[206] + "' != '" + 68 + "'", - value.equals(BigInteger.valueOf(68L))); + org.junit.Assert.assertTrue("'" + msg.contents[206] + "' != '" + 68 + "'", value.equals(BigInteger.valueOf( 68L ) ) ); } else { value = value.longValue(); expected = 68L; @@ -2363,9 +1698,7 @@ public void test1() throws Throwable { } value = msg.contents[207]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[207] + "' != '" + 200 + "'", - value.equals(BigInteger.valueOf(200L))); + org.junit.Assert.assertTrue("'" + msg.contents[207] + "' != '" + 200 + "'", value.equals(BigInteger.valueOf( 200L ) ) ); } else { value = value.longValue(); expected = 200L; @@ -2373,9 +1706,7 @@ public void test1() throws Throwable { } value = msg.contents[208]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[208] + "' != '" + 38 + "'", - value.equals(BigInteger.valueOf(38L))); + org.junit.Assert.assertTrue("'" + msg.contents[208] + "' != '" + 38 + "'", value.equals(BigInteger.valueOf( 38L ) ) ); } else { value = value.longValue(); expected = 38L; @@ -2383,9 +1714,7 @@ public void test1() throws Throwable { } value = msg.contents[209]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[209] + "' != '" + 139 + "'", - value.equals(BigInteger.valueOf(139L))); + org.junit.Assert.assertTrue("'" + msg.contents[209] + "' != '" + 139 + "'", value.equals(BigInteger.valueOf( 139L ) ) ); } else { value = value.longValue(); expected = 139L; @@ -2393,9 +1722,7 @@ public void test1() throws Throwable { } value = msg.contents[210]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[210] + "' != '" + 212 + "'", - value.equals(BigInteger.valueOf(212L))); + org.junit.Assert.assertTrue("'" + msg.contents[210] + "' != '" + 212 + "'", value.equals(BigInteger.valueOf( 212L ) ) ); } else { value = value.longValue(); expected = 212L; @@ -2403,9 +1730,7 @@ public void test1() throws Throwable { } value = msg.contents[211]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[211] + "' != '" + 112 + "'", - value.equals(BigInteger.valueOf(112L))); + org.junit.Assert.assertTrue("'" + msg.contents[211] + "' != '" + 112 + "'", value.equals(BigInteger.valueOf( 112L ) ) ); } else { value = value.longValue(); expected = 112L; @@ -2413,9 +1738,7 @@ public void test1() throws Throwable { } value = msg.contents[212]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[212] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.contents[212] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -2423,9 +1746,7 @@ public void test1() throws Throwable { } value = msg.contents[213]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[213] + "' != '" + 167 + "'", - value.equals(BigInteger.valueOf(167L))); + org.junit.Assert.assertTrue("'" + msg.contents[213] + "' != '" + 167 + "'", value.equals(BigInteger.valueOf( 167L ) ) ); } else { value = value.longValue(); expected = 167L; @@ -2433,9 +1754,7 @@ public void test1() throws Throwable { } value = msg.contents[214]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[214] + "' != '" + 236 + "'", - value.equals(BigInteger.valueOf(236L))); + org.junit.Assert.assertTrue("'" + msg.contents[214] + "' != '" + 236 + "'", value.equals(BigInteger.valueOf( 236L ) ) ); } else { value = value.longValue(); expected = 236L; @@ -2443,9 +1762,7 @@ public void test1() throws Throwable { } value = msg.contents[215]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[215] + "' != '" + 255 + "'", - value.equals(BigInteger.valueOf(255L))); + org.junit.Assert.assertTrue("'" + msg.contents[215] + "' != '" + 255 + "'", value.equals(BigInteger.valueOf( 255L ) ) ); } else { value = value.longValue(); expected = 255L; @@ -2453,9 +1770,7 @@ public void test1() throws Throwable { } value = msg.contents[216]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[216] + "' != '" + 106 + "'", - value.equals(BigInteger.valueOf(106L))); + org.junit.Assert.assertTrue("'" + msg.contents[216] + "' != '" + 106 + "'", value.equals(BigInteger.valueOf( 106L ) ) ); } else { value = value.longValue(); expected = 106L; @@ -2463,9 +1778,7 @@ public void test1() throws Throwable { } value = msg.contents[217]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[217] + "' != '" + 92 + "'", - value.equals(BigInteger.valueOf(92L))); + org.junit.Assert.assertTrue("'" + msg.contents[217] + "' != '" + 92 + "'", value.equals(BigInteger.valueOf( 92L ) ) ); } else { value = value.longValue(); expected = 92L; @@ -2473,9 +1786,7 @@ public void test1() throws Throwable { } value = msg.contents[218]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[218] + "' != '" + 132 + "'", - value.equals(BigInteger.valueOf(132L))); + org.junit.Assert.assertTrue("'" + msg.contents[218] + "' != '" + 132 + "'", value.equals(BigInteger.valueOf( 132L ) ) ); } else { value = value.longValue(); expected = 132L; @@ -2483,9 +1794,7 @@ public void test1() throws Throwable { } value = msg.contents[219]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[219] + "' != '" + 59 + "'", - value.equals(BigInteger.valueOf(59L))); + org.junit.Assert.assertTrue("'" + msg.contents[219] + "' != '" + 59 + "'", value.equals(BigInteger.valueOf( 59L ) ) ); } else { value = value.longValue(); expected = 59L; @@ -2493,9 +1802,7 @@ public void test1() throws Throwable { } value = msg.contents[220]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[220] + "' != '" + 61 + "'", - value.equals(BigInteger.valueOf(61L))); + org.junit.Assert.assertTrue("'" + msg.contents[220] + "' != '" + 61 + "'", value.equals(BigInteger.valueOf( 61L ) ) ); } else { value = value.longValue(); expected = 61L; @@ -2503,9 +1810,7 @@ public void test1() throws Throwable { } value = msg.contents[221]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[221] + "' != '" + 233 + "'", - value.equals(BigInteger.valueOf(233L))); + org.junit.Assert.assertTrue("'" + msg.contents[221] + "' != '" + 233 + "'", value.equals(BigInteger.valueOf( 233L ) ) ); } else { value = value.longValue(); expected = 233L; @@ -2513,9 +1818,7 @@ public void test1() throws Throwable { } value = msg.contents[222]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[222] + "' != '" + 3 + "'", - value.equals(BigInteger.valueOf(3L))); + org.junit.Assert.assertTrue("'" + msg.contents[222] + "' != '" + 3 + "'", value.equals(BigInteger.valueOf( 3L ) ) ); } else { value = value.longValue(); expected = 3L; @@ -2523,9 +1826,7 @@ public void test1() throws Throwable { } value = msg.contents[223]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[223] + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.contents[223] + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -2533,9 +1834,7 @@ public void test1() throws Throwable { } value = msg.contents[224]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[224] + "' != '" + 158 + "'", - value.equals(BigInteger.valueOf(158L))); + org.junit.Assert.assertTrue("'" + msg.contents[224] + "' != '" + 158 + "'", value.equals(BigInteger.valueOf( 158L ) ) ); } else { value = value.longValue(); expected = 158L; @@ -2543,9 +1842,7 @@ public void test1() throws Throwable { } value = msg.contents[225]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[225] + "' != '" + 83 + "'", - value.equals(BigInteger.valueOf(83L))); + org.junit.Assert.assertTrue("'" + msg.contents[225] + "' != '" + 83 + "'", value.equals(BigInteger.valueOf( 83L ) ) ); } else { value = value.longValue(); expected = 83L; @@ -2553,9 +1850,7 @@ public void test1() throws Throwable { } value = msg.contents[226]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[226] + "' != '" + 134 + "'", - value.equals(BigInteger.valueOf(134L))); + org.junit.Assert.assertTrue("'" + msg.contents[226] + "' != '" + 134 + "'", value.equals(BigInteger.valueOf( 134L ) ) ); } else { value = value.longValue(); expected = 134L; @@ -2563,9 +1858,7 @@ public void test1() throws Throwable { } value = msg.contents[227]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[227] + "' != '" + 246 + "'", - value.equals(BigInteger.valueOf(246L))); + org.junit.Assert.assertTrue("'" + msg.contents[227] + "' != '" + 246 + "'", value.equals(BigInteger.valueOf( 246L ) ) ); } else { value = value.longValue(); expected = 246L; @@ -2573,9 +1866,7 @@ public void test1() throws Throwable { } value = msg.contents[228]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[228] + "' != '" + 154 + "'", - value.equals(BigInteger.valueOf(154L))); + org.junit.Assert.assertTrue("'" + msg.contents[228] + "' != '" + 154 + "'", value.equals(BigInteger.valueOf( 154L ) ) ); } else { value = value.longValue(); expected = 154L; @@ -2583,9 +1874,7 @@ public void test1() throws Throwable { } value = msg.contents[229]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[229] + "' != '" + 17 + "'", - value.equals(BigInteger.valueOf(17L))); + org.junit.Assert.assertTrue("'" + msg.contents[229] + "' != '" + 17 + "'", value.equals(BigInteger.valueOf( 17L ) ) ); } else { value = value.longValue(); expected = 17L; @@ -2593,9 +1882,7 @@ public void test1() throws Throwable { } value = msg.contents[230]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[230] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.contents[230] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2603,9 +1890,7 @@ public void test1() throws Throwable { } value = msg.contents[231]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[231] + "' != '" + 6 + "'", - value.equals(BigInteger.valueOf(6L))); + org.junit.Assert.assertTrue("'" + msg.contents[231] + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; @@ -2613,9 +1898,7 @@ public void test1() throws Throwable { } value = msg.contents[232]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[232] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.contents[232] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -2623,9 +1906,7 @@ public void test1() throws Throwable { } value = msg.contents[233]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[233] + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.contents[233] + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -2633,9 +1914,7 @@ public void test1() throws Throwable { } value = msg.contents[234]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[234] + "' != '" + 19 + "'", - value.equals(BigInteger.valueOf(19L))); + org.junit.Assert.assertTrue("'" + msg.contents[234] + "' != '" + 19 + "'", value.equals(BigInteger.valueOf( 19L ) ) ); } else { value = value.longValue(); expected = 19L; @@ -2643,9 +1922,7 @@ public void test1() throws Throwable { } value = msg.contents[235]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[235] + "' != '" + 216 + "'", - value.equals(BigInteger.valueOf(216L))); + org.junit.Assert.assertTrue("'" + msg.contents[235] + "' != '" + 216 + "'", value.equals(BigInteger.valueOf( 216L ) ) ); } else { value = value.longValue(); expected = 216L; @@ -2653,9 +1930,7 @@ public void test1() throws Throwable { } value = msg.contents[236]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[236] + "' != '" + 70 + "'", - value.equals(BigInteger.valueOf(70L))); + org.junit.Assert.assertTrue("'" + msg.contents[236] + "' != '" + 70 + "'", value.equals(BigInteger.valueOf( 70L ) ) ); } else { value = value.longValue(); expected = 70L; @@ -2663,9 +1938,7 @@ public void test1() throws Throwable { } value = msg.contents[237]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[237] + "' != '" + 71 + "'", - value.equals(BigInteger.valueOf(71L))); + org.junit.Assert.assertTrue("'" + msg.contents[237] + "' != '" + 71 + "'", value.equals(BigInteger.valueOf( 71L ) ) ); } else { value = value.longValue(); expected = 71L; @@ -2673,9 +1946,7 @@ public void test1() throws Throwable { } value = msg.contents[238]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[238] + "' != '" + 161 + "'", - value.equals(BigInteger.valueOf(161L))); + org.junit.Assert.assertTrue("'" + msg.contents[238] + "' != '" + 161 + "'", value.equals(BigInteger.valueOf( 161L ) ) ); } else { value = value.longValue(); expected = 161L; @@ -2683,9 +1954,7 @@ public void test1() throws Throwable { } value = msg.contents[239]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[239] + "' != '" + 184 + "'", - value.equals(BigInteger.valueOf(184L))); + org.junit.Assert.assertTrue("'" + msg.contents[239] + "' != '" + 184 + "'", value.equals(BigInteger.valueOf( 184L ) ) ); } else { value = value.longValue(); expected = 184L; @@ -2693,9 +1962,7 @@ public void test1() throws Throwable { } value = msg.contents[240]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[240] + "' != '" + 5 + "'", - value.equals(BigInteger.valueOf(5L))); + org.junit.Assert.assertTrue("'" + msg.contents[240] + "' != '" + 5 + "'", value.equals(BigInteger.valueOf( 5L ) ) ); } else { value = value.longValue(); expected = 5L; @@ -2703,9 +1970,7 @@ public void test1() throws Throwable { } value = msg.contents[241]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[241] + "' != '" + 177 + "'", - value.equals(BigInteger.valueOf(177L))); + org.junit.Assert.assertTrue("'" + msg.contents[241] + "' != '" + 177 + "'", value.equals(BigInteger.valueOf( 177L ) ) ); } else { value = value.longValue(); expected = 177L; @@ -2713,9 +1978,7 @@ public void test1() throws Throwable { } value = msg.contents[242]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[242] + "' != '" + 45 + "'", - value.equals(BigInteger.valueOf(45L))); + org.junit.Assert.assertTrue("'" + msg.contents[242] + "' != '" + 45 + "'", value.equals(BigInteger.valueOf( 45L ) ) ); } else { value = value.longValue(); expected = 45L; @@ -2723,9 +1986,7 @@ public void test1() throws Throwable { } value = msg.contents[243]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[243] + "' != '" + 37 + "'", - value.equals(BigInteger.valueOf(37L))); + org.junit.Assert.assertTrue("'" + msg.contents[243] + "' != '" + 37 + "'", value.equals(BigInteger.valueOf( 37L ) ) ); } else { value = value.longValue(); expected = 37L; @@ -2733,9 +1994,7 @@ public void test1() throws Throwable { } value = msg.contents[244]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[244] + "' != '" + 98 + "'", - value.equals(BigInteger.valueOf(98L))); + org.junit.Assert.assertTrue("'" + msg.contents[244] + "' != '" + 98 + "'", value.equals(BigInteger.valueOf( 98L ) ) ); } else { value = value.longValue(); expected = 98L; @@ -2743,9 +2002,7 @@ public void test1() throws Throwable { } value = msg.contents[245]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[245] + "' != '" + 56 + "'", - value.equals(BigInteger.valueOf(56L))); + org.junit.Assert.assertTrue("'" + msg.contents[245] + "' != '" + 56 + "'", value.equals(BigInteger.valueOf( 56L ) ) ); } else { value = value.longValue(); expected = 56L; @@ -2753,9 +2010,7 @@ public void test1() throws Throwable { } value = msg.contents[246]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[246] + "' != '" + 149 + "'", - value.equals(BigInteger.valueOf(149L))); + org.junit.Assert.assertTrue("'" + msg.contents[246] + "' != '" + 149 + "'", value.equals(BigInteger.valueOf( 149L ) ) ); } else { value = value.longValue(); expected = 149L; @@ -2763,9 +2018,7 @@ public void test1() throws Throwable { } value = msg.contents[247]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[247] + "' != '" + 0 + "'", - value.equals(BigInteger.valueOf(0L))); + org.junit.Assert.assertTrue("'" + msg.contents[247] + "' != '" + 0 + "'", value.equals(BigInteger.valueOf( 0L ) ) ); } else { value = value.longValue(); expected = 0L; @@ -2773,9 +2026,7 @@ public void test1() throws Throwable { } value = msg.contents[248]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[248] + "' != '" + 73 + "'", - value.equals(BigInteger.valueOf(73L))); + org.junit.Assert.assertTrue("'" + msg.contents[248] + "' != '" + 73 + "'", value.equals(BigInteger.valueOf( 73L ) ) ); } else { value = value.longValue(); expected = 73L; @@ -2783,9 +2034,7 @@ public void test1() throws Throwable { } value = msg.contents[249]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[249] + "' != '" + 221 + "'", - value.equals(BigInteger.valueOf(221L))); + org.junit.Assert.assertTrue("'" + msg.contents[249] + "' != '" + 221 + "'", value.equals(BigInteger.valueOf( 221L ) ) ); } else { value = value.longValue(); expected = 221L; @@ -2793,9 +2042,7 @@ public void test1() throws Throwable { } value = msg.contents[250]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[250] + "' != '" + 105 + "'", - value.equals(BigInteger.valueOf(105L))); + org.junit.Assert.assertTrue("'" + msg.contents[250] + "' != '" + 105 + "'", value.equals(BigInteger.valueOf( 105L ) ) ); } else { value = value.longValue(); expected = 105L; @@ -2803,9 +2050,7 @@ public void test1() throws Throwable { } value = msg.contents[251]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[251] + "' != '" + 239 + "'", - value.equals(BigInteger.valueOf(239L))); + org.junit.Assert.assertTrue("'" + msg.contents[251] + "' != '" + 239 + "'", value.equals(BigInteger.valueOf( 239L ) ) ); } else { value = value.longValue(); expected = 239L; @@ -2813,9 +2058,7 @@ public void test1() throws Throwable { } value = msg.contents[252]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[252] + "' != '" + 168 + "'", - value.equals(BigInteger.valueOf(168L))); + org.junit.Assert.assertTrue("'" + msg.contents[252] + "' != '" + 168 + "'", value.equals(BigInteger.valueOf( 168L ) ) ); } else { value = value.longValue(); expected = 168L; @@ -2823,9 +2066,7 @@ public void test1() throws Throwable { } value = msg.contents[253]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[253] + "' != '" + 205 + "'", - value.equals(BigInteger.valueOf(205L))); + org.junit.Assert.assertTrue("'" + msg.contents[253] + "' != '" + 205 + "'", value.equals(BigInteger.valueOf( 205L ) ) ); } else { value = value.longValue(); expected = 205L; @@ -2833,9 +2074,7 @@ public void test1() throws Throwable { } value = msg.contents[254]; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.contents[254] + "' != '" + 85 + "'", - value.equals(BigInteger.valueOf(85L))); + org.junit.Assert.assertTrue("'" + msg.contents[254] + "' != '" + 85 + "'", value.equals(BigInteger.valueOf( 85L ) ) ); } else { value = value.longValue(); expected = 85L; diff --git a/java/test/auto_check_sbp_vehicle_MsgOdometryTest.java b/java/test/auto_check_sbp_vehicle_MsgOdometryTest.java index 99e29c52b..6cb273f6d 100644 --- a/java/test/auto_check_sbp_vehicle_MsgOdometryTest.java +++ b/java/test/auto_check_sbp_vehicle_MsgOdometryTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/vehicle/test_MsgOdometry.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/vehicle/test_MsgOdometry.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.vehicle.MsgOdometry; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_vehicle_MsgOdometryTest { @@ -27,21 +32,17 @@ public class auto_check_sbp_vehicle_MsgOdometryTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_vehicle_MsgOdometryTest.test1"); - byte[] payload = - new byte[] { - (byte) 8, (byte) 0, (byte) 0, (byte) 0, (byte) 7, (byte) 0, (byte) 0, (byte) 0, - (byte) 1, - }; - SBPMessage sbp = new SBPMessage(0x42, 0x903, payload); - MsgOdometry msg = new MsgOdometry(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_vehicle_MsgOdometryTest.test1"); + byte[] payload = new byte[] {(byte)8,(byte)0,(byte)0,(byte)0,(byte)7,(byte)0,(byte)0,(byte)0,(byte)1, }; + SBPMessage sbp = new SBPMessage( 0x42, 0x903, payload ); + MsgOdometry msg = new MsgOdometry( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -49,8 +50,7 @@ public void test1() throws Throwable { } value = msg.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.tow + "' != '" + 8 + "'", value.equals(BigInteger.valueOf(8L))); + org.junit.Assert.assertTrue("'" + msg.tow + "' != '" + 8 + "'", value.equals(BigInteger.valueOf( 8L ) ) ); } else { value = value.longValue(); expected = 8L; @@ -58,8 +58,7 @@ public void test1() throws Throwable { } value = msg.velocity; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.velocity + "' != '" + 7 + "'", value.equals(BigInteger.valueOf(7L))); + org.junit.Assert.assertTrue("'" + msg.velocity + "' != '" + 7 + "'", value.equals(BigInteger.valueOf( 7L ) ) ); } else { value = value.longValue(); expected = 7L; diff --git a/java/test/auto_check_sbp_vehicle_MsgWheeltickTest.java b/java/test/auto_check_sbp_vehicle_MsgWheeltickTest.java index d7407fbde..0ae9ccd19 100644 --- a/java/test/auto_check_sbp_vehicle_MsgWheeltickTest.java +++ b/java/test/auto_check_sbp_vehicle_MsgWheeltickTest.java @@ -1,4 +1,5 @@ -/* Copyright (C) 2015-2022 Swift Navigation Inc. +/* + * Copyright (C) 2015-2021 Swift Navigation Inc. * Contact: https://support.swiftnav.com * * This source is subject to the license found in the file 'LICENSE' which must @@ -8,17 +9,21 @@ * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. */ + package com.swiftnav.sbp.test; -// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/vehicle/test_MsgWheeltick.yaml by -// generate.py. Do not modify by hand! +// This file was auto-generated from spec/tests/yaml/swiftnav/sbp/vehicle/test_MsgWheeltick.yaml by generate.py. Do not modify by hand! + +import java.math.BigInteger; + +import org.junit.Test; +import org.json.JSONObject; import com.swiftnav.sbp.SBPMessage; + import com.swiftnav.sbp.vehicle.MsgWheeltick; -import java.math.BigInteger; -import org.json.JSONObject; -import org.junit.Test; + public class auto_check_sbp_vehicle_MsgWheeltickTest { @@ -27,21 +32,17 @@ public class auto_check_sbp_vehicle_MsgWheeltickTest { @Test public void test1() throws Throwable { - if (debug) System.out.format("%n%s%n", "auto_check_sbp_vehicle_MsgWheeltickTest.test1"); - byte[] payload = - new byte[] { - (byte) 254, (byte) 27, (byte) 114, (byte) 44, (byte) 26, (byte) 0, (byte) 0, - (byte) 0, (byte) 1, (byte) 146, (byte) 225, (byte) 51, (byte) 9, (byte) 210, - }; - SBPMessage sbp = new SBPMessage(0x456b, 0x904, payload); - MsgWheeltick msg = new MsgWheeltick(sbp); + if (debug) + System.out.format("%n%s%n", "auto_check_sbp_vehicle_MsgWheeltickTest.test1"); + byte[] payload = new byte[] {(byte)254,(byte)27,(byte)114,(byte)44,(byte)26,(byte)0,(byte)0,(byte)0,(byte)1,(byte)146,(byte)225,(byte)51,(byte)9,(byte)210, }; + SBPMessage sbp = new SBPMessage( 0x456b, 0x904, payload ); + MsgWheeltick msg = new MsgWheeltick( sbp ); JSONObject json = msg.toJSON(); Number value; Number expected; value = msg.flags; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf(1L))); + org.junit.Assert.assertTrue("'" + msg.flags + "' != '" + 1 + "'", value.equals(BigInteger.valueOf( 1L ) ) ); } else { value = value.longValue(); expected = 1L; @@ -49,9 +50,7 @@ public void test1() throws Throwable { } value = msg.source; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.source + "' != '" + 146 + "'", - value.equals(BigInteger.valueOf(146L))); + org.junit.Assert.assertTrue("'" + msg.source + "' != '" + 146 + "'", value.equals(BigInteger.valueOf( 146L ) ) ); } else { value = value.longValue(); expected = 146L; @@ -59,9 +58,7 @@ public void test1() throws Throwable { } value = msg.ticks; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.ticks + "' != '" + -771148831 + "'", - value.equals(BigInteger.valueOf(-771148831L))); + org.junit.Assert.assertTrue("'" + msg.ticks + "' != '" + -771148831 + "'", value.equals(BigInteger.valueOf( -771148831L ) ) ); } else { value = value.longValue(); expected = -771148831L; @@ -69,9 +66,7 @@ public void test1() throws Throwable { } value = msg.time; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue( - "'" + msg.time + "' != '" + 112414825470L + "'", - value.equals(new BigInteger("112414825470"))); + org.junit.Assert.assertTrue("'" + msg.time + "' != '" + 112414825470L + "'", value.equals( new BigInteger( "112414825470" ) ) ); } else { value = value.longValue(); expected = 112414825470L; diff --git a/javascript/sbp/integrity.js b/javascript/sbp/integrity.js index 555191b17..3f2bb9933 100644 --- a/javascript/sbp/integrity.js +++ b/javascript/sbp/integrity.js @@ -162,7 +162,7 @@ MsgSsrFlagHighLevelDepA.prototype.fieldSpec.push(['use_iono_grid_point_sat_los', * * Fields in the SBP payload (`sbp.payload`): * @field obs_time GPSTimeSec GNSS reference time of the observation used to generate the flag. - * @field atmo_corr_time GPSTimeSec GNSS reference time of the atmospheric correction associated to the flag. + * @field iono_corr_time GPSTimeSec GNSS reference time of the ionospheric correction associated to the flag. * @field sat_corr_time GPSTimeSec GNSS reference time of the satellite correction associated to the flag. * @field ssr_sol_id number (unsigned 8-bit int, 1 byte) SSR Solution ID. * @field tile_set_id number (unsigned 16-bit int, 2 bytes) Unique identifier of the set this tile belongs to. @@ -194,7 +194,7 @@ MsgSsrFlagHighLevel.prototype.constructor = MsgSsrFlagHighLevel; MsgSsrFlagHighLevel.prototype.parser = new Parser() .endianess('little') .nest('obs_time', { type: GPSTimeSec.prototype.parser }) - .nest('atmo_corr_time', { type: GPSTimeSec.prototype.parser }) + .nest('iono_corr_time', { type: GPSTimeSec.prototype.parser }) .nest('sat_corr_time', { type: GPSTimeSec.prototype.parser }) .uint8('ssr_sol_id') .uint16('tile_set_id') @@ -211,7 +211,7 @@ MsgSsrFlagHighLevel.prototype.parser = new Parser() .uint8('use_iono_grid_point_sat_los'); MsgSsrFlagHighLevel.prototype.fieldSpec = []; MsgSsrFlagHighLevel.prototype.fieldSpec.push(['obs_time', GPSTimeSec.prototype.fieldSpec]); -MsgSsrFlagHighLevel.prototype.fieldSpec.push(['atmo_corr_time', GPSTimeSec.prototype.fieldSpec]); +MsgSsrFlagHighLevel.prototype.fieldSpec.push(['iono_corr_time', GPSTimeSec.prototype.fieldSpec]); MsgSsrFlagHighLevel.prototype.fieldSpec.push(['sat_corr_time', GPSTimeSec.prototype.fieldSpec]); MsgSsrFlagHighLevel.prototype.fieldSpec.push(['ssr_sol_id', 'writeUInt8', 1]); MsgSsrFlagHighLevel.prototype.fieldSpec.push(['tile_set_id', 'writeUInt16LE', 2]); diff --git a/jsonschema/MsgSsrFlagHighLevel.json b/jsonschema/MsgSsrFlagHighLevel.json index 31bf98024..8a5090a8e 100644 --- a/jsonschema/MsgSsrFlagHighLevel.json +++ b/jsonschema/MsgSsrFlagHighLevel.json @@ -12,29 +12,29 @@ ], "$schema": "http://json-schema.org/draft-06/schema#", "$id": "#MsgSsrFlagHighLevel", - "title":"MsgSsrFlagHighLevel", - "description":"Integrity monitoring flags for multiple aggregated elements. An element could be a satellite, SSR grid point, or SSR tile. A group of aggregated elements being monitored for integrity could refer to:,\n,\n- Satellites in a particular {GPS, GAL, BDS, QZSS} constellation.,\n,\n- Satellites in the line-of-sight of a particular SSR tile.,\n,\n- Satellites in the line-of-sight of a particular SSR grid point.,\n,\nThe integrity usage for a group of aggregated elements varies according to the integrity flag of the satellites comprising that group.,\n,\nSSR_INTEGRITY_USAGE_NOMINAL: All satellites received passed the integrity check and have flag INTEGRITY_FLAG_OK.,\n,\nSSR_INTEGRITY_USAGE_WARNING: A limited number of elements in the group failed the integrity check. Refer to more granular integrity messages for details on the specific failing elements.,\n,\nSSR_INTEGRITY_USAGE_ALERT: Most elements in the group failed the integrity check, do not use for positioning.,\n,\nSSR_INTEGRITY_USAGE_NOT_MONITORED: Unable to verify the integrity flag of elements in the group.\n", + "title": "MsgSsrFlagHighLevel", + "description": "Integrity monitoring flags for multiple aggregated elements. An element could be a satellite, SSR grid point, or SSR tile. A group of aggregated elements being monitored for integrity could refer to:,\n,\n- Satellites in a particular {GPS, GAL, BDS, QZSS} constellation.,\n,\n- Satellites in the line-of-sight of a particular SSR tile.,\n,\n- Satellites in the line-of-sight of a particular SSR grid point.,\n,\nThe integrity usage for a group of aggregated elements varies according to the integrity flag of the satellites comprising that group.,\n,\nSSR_INTEGRITY_USAGE_NOMINAL: All satellites received passed the integrity check and have flag INTEGRITY_FLAG_OK.,\n,\nSSR_INTEGRITY_USAGE_WARNING: A limited number of elements in the group failed the integrity check. Refer to more granular integrity messages for details on the specific failing elements.,\n,\nSSR_INTEGRITY_USAGE_ALERT: Most elements in the group failed the integrity check, do not use for positioning.,\n,\nSSR_INTEGRITY_USAGE_NOT_MONITORED: Unable to verify the integrity flag of elements in the group.\n", "type": "object", "properties": { - "obs_time": {"$ref": "GpsTimeSec.json"}, - "atmo_corr_time": {"$ref": "GpsTimeSec.json"}, - "sat_corr_time": {"$ref": "GpsTimeSec.json"}, - "ssr_sol_id": {"type": "integer"}, - "tile_set_id": {"type": "integer"}, - "tile_id": {"type": "integer"}, - "chain_id": {"type": "integer"}, - "use_gps_sat": {"type": "integer"}, - "use_gal_sat": {"type": "integer"}, - "use_bds_sat": {"type": "integer"}, - "use_qzss_sat": {"type": "integer"}, - "use_tropo_grid_points": {"type": "integer"}, - "use_iono_grid_points": {"type": "integer"}, - "use_iono_tile_sat_los": {"type": "integer"}, - "use_iono_grid_point_sat_los": {"type": "integer"} + "obs_time": { "$ref": "GpsTimeSec.json" }, + "iono_corr_time": { "$ref": "GpsTimeSec.json" }, + "sat_corr_time": { "$ref": "GpsTimeSec.json" }, + "ssr_sol_id": { "type": "integer" }, + "tile_set_id": { "type": "integer" }, + "tile_id": { "type": "integer" }, + "chain_id": { "type": "integer" }, + "use_gps_sat": { "type": "integer" }, + "use_gal_sat": { "type": "integer" }, + "use_bds_sat": { "type": "integer" }, + "use_qzss_sat": { "type": "integer" }, + "use_tropo_grid_points": { "type": "integer" }, + "use_iono_grid_points": { "type": "integer" }, + "use_iono_tile_sat_los": { "type": "integer" }, + "use_iono_grid_point_sat_los": { "type": "integer" } }, "required": [ "obs_time", - "atmo_corr_time", + "iono_corr_time", "sat_corr_time", "ssr_sol_id", "tile_set_id", diff --git a/kaitai/ksy/integrity.ksy b/kaitai/ksy/integrity.ksy index 0d713b832..a74112ff3 100644 --- a/kaitai/ksy/integrity.ksy +++ b/kaitai/ksy/integrity.ksy @@ -50,7 +50,7 @@ types: doc: | Chain and type of flag. type: u1 - + msg_ssr_flag_high_level_dep_a: doc: | Deprecated. @@ -117,7 +117,7 @@ types: doc: | Use iono grid point satellite LoS. type: u1 - + msg_ssr_flag_high_level: doc: | Integrity monitoring flags for multiple aggregated elements. An element @@ -150,7 +150,7 @@ types: doc: | GNSS reference time of the observation used to generate the flag. type: gnss::gps_time_sec - - id: atmo_corr_time + - id: iono_corr_time doc: | GNSS reference time of the atmospheric correction associated to the flag. @@ -214,7 +214,7 @@ types: doc: | Use iono grid point satellite LoS. type: u1 - + msg_ssr_flag_satellites: seq: - id: obs_time @@ -250,7 +250,7 @@ types: List of faulty satellites. type: u1 repeat: eos - + msg_ssr_flag_tropo_grid_points: seq: - id: header @@ -266,7 +266,7 @@ types: List of faulty grid points. type: u2 repeat: eos - + msg_ssr_flag_iono_grid_points: seq: - id: header @@ -282,7 +282,7 @@ types: List of faulty grid points. type: u2 repeat: eos - + msg_ssr_flag_iono_tile_sat_los: seq: - id: header @@ -298,7 +298,7 @@ types: List of faulty LOS type: gnss::sv_id repeat: eos - + msg_ssr_flag_iono_grid_point_sat_los: seq: - id: header @@ -318,7 +318,7 @@ types: List of faulty LOS type: gnss::sv_id repeat: eos - + msg_acknowledge: seq: - id: request_id @@ -348,4 +348,4 @@ types: doc: | The solution ID of the instance providing the corrections. type: u1 - + diff --git a/kaitai/perl/KaitaiSbp/Integrity.pm b/kaitai/perl/KaitaiSbp/Integrity.pm index a842bf1be..f88e6f1bb 100644 --- a/kaitai/perl/KaitaiSbp/Integrity.pm +++ b/kaitai/perl/KaitaiSbp/Integrity.pm @@ -637,7 +637,7 @@ sub _read { my ($self) = @_; $self->{obs_time} = Gnss::GpsTimeSec->new($self->{_io}, $self, $self->{_root}); - $self->{atmo_corr_time} = Gnss::GpsTimeSec->new($self->{_io}, $self, $self->{_root}); + $self->{iono_corr_time} = Gnss::GpsTimeSec->new($self->{_io}, $self, $self->{_root}); $self->{sat_corr_time} = Gnss::GpsTimeSec->new($self->{_io}, $self, $self->{_root}); $self->{ssr_sol_id} = $self->{_io}->read_u1(); $self->{tile_set_id} = $self->{_io}->read_u2le(); @@ -663,9 +663,9 @@ sub obs_time { return $self->{obs_time}; } -sub atmo_corr_time { +sub iono_corr_time { my ($self) = @_; - return $self->{atmo_corr_time}; + return $self->{iono_corr_time}; } sub sat_corr_time { diff --git a/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevel.t b/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevel.t index d36470c81..d80b5b114 100644 --- a/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevel.t +++ b/kaitai/perl/KaitaiSbp/t/auto_check_sbp_integrity_MsgSsrFlagHighLevel.t @@ -32,54 +32,54 @@ sub test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1() { my $buf = decode_base64("VbkLQgAftAAAAAMAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCGkD"); my $stream = IO::KaitaiStruct::Stream->new($buf); my $msg = ParseUtils::get_flattened_msg(Sbp::SbpMessage->new($stream)); - + is($msg->{'preamble'}, 0x55, "preamble"); - + is($msg->{'msg_type'}, 0x0BBA, "msg_type"); - + is($msg->{'sender'}, 0x0042, "sender"); - + is($msg->{'length'}, 31, "length"); - + is($msg->{'payload'}, "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "payload"); - + is($msg->{'crc'}, 0xBE9D, "crc"); my $json = JSON::PP->new->convert_blessed->canonical; - - is($json->encode($msg->atmo_corr_time()), $json->encode($json->decode(q{{"tow":365,"wn":6}})), "atmo_corr_time"); - + + is($json->encode($msg->iono_corr_time()), $json->encode($json->decode(q{{"tow":365,"wn":6}})), "iono_corr_time"); + is($msg->chain_id(), 40, "chain_id"); - + is($json->encode($msg->obs_time()), $json->encode($json->decode(q{{"tow":180,"wn":3}})), "obs_time"); - + is($json->encode($msg->reserved()), $json->encode($json->decode(q{[0,0,0,0,0]})), "reserved"); - + is($json->encode($msg->sat_corr_time()), $json->encode($json->decode(q{{"tow":360,"wn":6}})), "sat_corr_time"); - + is($msg->ssr_sol_id(), 10, "ssr_sol_id"); - + is($msg->tile_id(), 30, "tile_id"); - + is($msg->tile_set_id(), 20, "tile_set_id"); - + is($msg->use_bds_sat(), 3, "use_bds_sat"); - + is($msg->use_gal_sat(), 2, "use_gal_sat"); - + is($msg->use_gps_sat(), 1, "use_gps_sat"); - + is($msg->use_iono_grid_point_sat_los(), 8, "use_iono_grid_point_sat_los"); - + is($msg->use_iono_grid_points(), 6, "use_iono_grid_points"); - + is($msg->use_iono_tile_sat_los(), 7, "use_iono_tile_sat_los"); - + is($msg->use_qzss_sat(), 4, "use_qzss_sat"); - + is($msg->use_tropo_grid_points(), 5, "use_tropo_grid_points"); - is($json->encode($msg), $json->encode($json->decode(q{{"atmo_corr_time":{"tow":365,"wn":6},"chain_id":40,"crc":48797,"length":31,"msg_type":3001,"obs_time":{"tow":180,"wn":3},"payload":"tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==","preamble":85,"reserved":[0,0,0,0,0],"sat_corr_time":{"tow":360,"wn":6},"sender":66,"ssr_sol_id":10,"tile_id":30,"tile_set_id":20,"use_bds_sat":3,"use_gal_sat":2,"use_gps_sat":1,"use_iono_grid_point_sat_los":8,"use_iono_grid_points":6,"use_iono_tile_sat_los":7,"use_qzss_sat":4,"use_tropo_grid_points":5}})), "raw_json"); + is($json->encode($msg), $json->encode($json->decode(q{{"iono_corr_time":{"tow":365,"wn":6},"chain_id":40,"crc":48797,"length":31,"msg_type":3001,"obs_time":{"tow":180,"wn":3},"payload":"tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==","preamble":85,"reserved":[0,0,0,0,0],"sat_corr_time":{"tow":360,"wn":6},"sender":66,"ssr_sol_id":10,"tile_id":30,"tile_set_id":20,"use_bds_sat":3,"use_gal_sat":2,"use_gps_sat":1,"use_iono_grid_point_sat_los":8,"use_iono_grid_points":6,"use_iono_tile_sat_los":7,"use_qzss_sat":4,"use_tropo_grid_points":5}})), "raw_json"); } test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1(); diff --git a/kaitai/python/kaitai_sbp/integrity.py b/kaitai/python/kaitai_sbp/integrity.py index 049a0ced1..a4cc93a60 100644 --- a/kaitai/python/kaitai_sbp/integrity.py +++ b/kaitai/python/kaitai_sbp/integrity.py @@ -181,26 +181,26 @@ class MsgSsrFlagHighLevel(KaitaiStruct): """Integrity monitoring flags for multiple aggregated elements. An element could be a satellite, SSR grid point, or SSR tile. A group of aggregated elements being monitored for integrity could refer to: - + - Satellites in a particular {GPS, GAL, BDS, QZSS} constellation. - + - Satellites in the line-of-sight of a particular SSR tile. - + - Satellites in the line-of-sight of a particular SSR grid point. - + The integrity usage for a group of aggregated elements varies according to the integrity flag of the satellites comprising that group. - + SSR_INTEGRITY_USAGE_NOMINAL: All satellites received passed the integrity check and have flag INTEGRITY_FLAG_OK. - + SSR_INTEGRITY_USAGE_WARNING: A limited number of elements in the group failed the integrity check. Refer to more granular integrity messages for details on the specific failing elements. - + SSR_INTEGRITY_USAGE_ALERT: Most elements in the group failed the integrity check, do not use for positioning. - + SSR_INTEGRITY_USAGE_NOT_MONITORED: Unable to verify the integrity flag of elements in the group. """ @@ -212,7 +212,7 @@ def __init__(self, _io, _parent=None, _root=None): def _read(self): self.obs_time = Gnss.GpsTimeSec(self._io, self, self._root) - self.atmo_corr_time = Gnss.GpsTimeSec(self._io, self, self._root) + self.iono_corr_time = Gnss.GpsTimeSec(self._io, self, self._root) self.sat_corr_time = Gnss.GpsTimeSec(self._io, self, self._root) self.ssr_sol_id = self._io.read_u1() self.tile_set_id = self._io.read_u2le() diff --git a/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevel.py b/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevel.py index f73445127..a87304332 100644 --- a/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevel.py +++ b/kaitai/python/kaitai_sbp/tests/test_auto_check_sbp_integrity_MsgSsrFlagHighLevel.py @@ -23,49 +23,49 @@ def test_auto_check_sbp_integrity_msg_ssr_flag_high_level_1(): stream = KaitaiStream(io.BytesIO(buf)) msg = get_flattened_msg(sbp.Sbp.SbpMessage(stream)) - + assert msg.preamble == 0x55 - + assert msg.msg_type == 0x0BBA - + assert msg.sender == 0x0042 - + assert msg.length == 31 - + assert msg.payload == "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==" - + assert msg.crc == 0xBE9D - - assert dictify(msg.atmo_corr_time) == {'tow': 365, 'wn': 6} - + + assert dictify(msg.iono_corr_time) == {'tow': 365, 'wn': 6} + assert dictify(msg.chain_id) == 40 - + assert dictify(msg.obs_time) == {'tow': 180, 'wn': 3} - + assert dictify(msg.reserved) == [0, 0, 0, 0, 0] - + assert dictify(msg.sat_corr_time) == {'tow': 360, 'wn': 6} - + assert dictify(msg.ssr_sol_id) == 10 - + assert dictify(msg.tile_id) == 30 - + assert dictify(msg.tile_set_id) == 20 - + assert dictify(msg.use_bds_sat) == 3 - + assert dictify(msg.use_gal_sat) == 2 - + assert dictify(msg.use_gps_sat) == 1 - + assert dictify(msg.use_iono_grid_point_sat_los) == 8 - + assert dictify(msg.use_iono_grid_points) == 6 - + assert dictify(msg.use_iono_tile_sat_los) == 7 - + assert dictify(msg.use_qzss_sat) == 4 - + assert dictify(msg.use_tropo_grid_points) == 5 - assert dictify(msg) == {'obs_time': {'tow': 180, 'wn': 3}, 'sat_corr_time': {'tow': 360, 'wn': 6}, 'atmo_corr_time': {'tow': 365, 'wn': 6}, 'ssr_sol_id': 10, 'tile_set_id': 20, 'tile_id': 30, 'chain_id': 40, 'use_gps_sat': 1, 'use_gal_sat': 2, 'use_bds_sat': 3, 'use_qzss_sat': 4, 'reserved': [0, 0, 0, 0, 0], 'use_tropo_grid_points': 5, 'use_iono_grid_points': 6, 'use_iono_tile_sat_los': 7, 'use_iono_grid_point_sat_los': 8, 'preamble': 85, 'msg_type': 3001, 'sender': 66, 'length': 31, 'payload': 'tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==', 'crc': 48797} + assert dictify(msg) == {'obs_time': {'tow': 180, 'wn': 3}, 'sat_corr_time': {'tow': 360, 'wn': 6}, 'iono_corr_time': {'tow': 365, 'wn': 6}, 'ssr_sol_id': 10, 'tile_set_id': 20, 'tile_id': 30, 'chain_id': 40, 'use_gps_sat': 1, 'use_gal_sat': 2, 'use_bds_sat': 3, 'use_qzss_sat': 4, 'reserved': [0, 0, 0, 0, 0], 'use_tropo_grid_points': 5, 'use_iono_grid_points': 6, 'use_iono_tile_sat_los': 7, 'use_iono_grid_point_sat_los': 8, 'preamble': 85, 'msg_type': 3001, 'sender': 66, 'length': 31, 'payload': 'tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==', 'crc': 48797} diff --git a/proto/integrity.proto b/proto/integrity.proto index 39fb6df38..28ce64b5e 100644 --- a/proto/integrity.proto +++ b/proto/integrity.proto @@ -65,7 +65,7 @@ message IntegritySSRHeader { */ message MsgSsrFlagHighLevel { gnss.GpsTimeSec obs_time = 1; - gnss.GpsTimeSec atmo_corr_time = 2; + gnss.GpsTimeSec iono_corr_time = 2; gnss.GpsTimeSec sat_corr_time = 3; uint32 ssr_sol_id = 4; uint32 tile_set_id = 5; diff --git a/sbpjson/elm/SbpJson.elm b/sbpjson/elm/SbpJson.elm index 4a631da1e..e44bcf73f 100644 --- a/sbpjson/elm/SbpJson.elm +++ b/sbpjson/elm/SbpJson.elm @@ -7279,7 +7279,7 @@ encodeCodePhaseBiasesSatSig x = msgSsrFlagHighLevel : Jdec.Decoder MsgSsrFlagHighLevel msgSsrFlagHighLevel = Jpipe.decode MsgSsrFlagHighLevel - |> Jpipe.required "atmo_corr_time" gpsTimeSEC + |> Jpipe.required "iono_corr_time" gpsTimeSEC |> Jpipe.required "chain_id" Jdec.int |> Jpipe.required "obs_time" gpsTimeSEC |> Jpipe.required "sat_corr_time" gpsTimeSEC @@ -7298,7 +7298,7 @@ msgSsrFlagHighLevel = encodeMsgSsrFlagHighLevel : MsgSsrFlagHighLevel -> Jenc.Value encodeMsgSsrFlagHighLevel x = Jenc.object - [ ("atmo_corr_time", encodeGpsTimeSEC x.atmoCorrTime) + [ ("iono_corr_time", encodeGpsTimeSEC x.atmoCorrTime) , ("chain_id", Jenc.int x.chainID) , ("obs_time", encodeGpsTimeSEC x.obsTime) , ("sat_corr_time", encodeGpsTimeSEC x.satCorrTime) diff --git a/sbpjson/typescript/SbpJson.ts b/sbpjson/typescript/SbpJson.ts index 911e338d5..9b8e073b8 100644 --- a/sbpjson/typescript/SbpJson.ts +++ b/sbpjson/typescript/SbpJson.ts @@ -2445,7 +2445,7 @@ export interface CodePhaseBiasesSatSig { * group. */ export interface MsgSsrFlagHighLevel { - atmo_corr_time: GpsTimeSEC; + iono_corr_time: GpsTimeSEC; chain_id: number; obs_time: GpsTimeSEC; sat_corr_time: GpsTimeSEC; @@ -6365,7 +6365,7 @@ const typeMap: any = { { json: "signal_id", js: "signal_id", typ: 0 }, ], "any"), "MsgSsrFlagHighLevel": o([ - { json: "atmo_corr_time", js: "atmo_corr_time", typ: r("GpsTimeSEC") }, + { json: "iono_corr_time", js: "iono_corr_time", typ: r("GpsTimeSEC") }, { json: "chain_id", js: "chain_id", typ: 0 }, { json: "obs_time", js: "obs_time", typ: r("GpsTimeSEC") }, { json: "sat_corr_time", js: "sat_corr_time", typ: r("GpsTimeSEC") }, From fe9e0db04a76c6dbdc4c975c0807948513b3d6a0 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Thu, 17 Jul 2025 18:30:41 +0200 Subject: [PATCH 08/10] OK --- ..._check_sbp_integrity_MsgSsrFlagHighLevel.c | 16 ++++---- ...check_sbp_integrity_MsgSsrFlagHighLevel.cc | 41 +++++++++---------- ...sbp_integrity_MsgSsrFlagHighLevelTest.java | 8 ++-- ...k_sbp_integrity_msg_ssr_flag_high_level.rs | 38 ++++++++--------- .../integrity/test_MsgSsrFlagHighLevel.yaml | 4 +- 5 files changed, 53 insertions(+), 54 deletions(-) diff --git a/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c index 25242e200..b927d3659 100644 --- a/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c +++ b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c @@ -104,9 +104,9 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { sbp_msg_t test_msg; memset(&test_msg, 0, sizeof(test_msg)); - test_msg.ssr_flag_high_level.atmo_corr_time.tow = 365; + test_msg.ssr_flag_high_level.iono_corr_time.tow = 365; - test_msg.ssr_flag_high_level.atmo_corr_time.wn = 6; + test_msg.ssr_flag_high_level.iono_corr_time.wn = 6; test_msg.ssr_flag_high_level.chain_id = 40; @@ -174,17 +174,17 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { sbp_message_cmp(SbpMsgSsrFlagHighLevel, &last_msg.msg, &test_msg) == 0, "Sent and received messages did not compare equal"); - ck_assert_msg(last_msg.msg.ssr_flag_high_level.atmo_corr_time.tow == 365, + ck_assert_msg(last_msg.msg.ssr_flag_high_level.iono_corr_time.tow == 365, "incorrect value for " - "last_msg.msg.ssr_flag_high_level.atmo_corr_time.tow, " + "last_msg.msg.ssr_flag_high_level.iono_corr_time.tow, " "expected 365, is %" PRId64, - (int64_t)last_msg.msg.ssr_flag_high_level.atmo_corr_time.tow); + (int64_t)last_msg.msg.ssr_flag_high_level.iono_corr_time.tow); - ck_assert_msg(last_msg.msg.ssr_flag_high_level.atmo_corr_time.wn == 6, + ck_assert_msg(last_msg.msg.ssr_flag_high_level.iono_corr_time.wn == 6, "incorrect value for " - "last_msg.msg.ssr_flag_high_level.atmo_corr_time.wn, " + "last_msg.msg.ssr_flag_high_level.iono_corr_time.wn, " "expected 6, is %" PRId64, - (int64_t)last_msg.msg.ssr_flag_high_level.atmo_corr_time.wn); + (int64_t)last_msg.msg.ssr_flag_high_level.iono_corr_time.wn); ck_assert_msg( last_msg.msg.ssr_flag_high_level.chain_id == 40, diff --git a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc index 46013567b..dc68cc71c 100644 --- a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc +++ b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc @@ -14,24 +14,23 @@ // spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml by // generate.py. Do not modify by hand! +#include #include #include #include #include -#include namespace { -template -void assign(T &dest, const U &source) { +template void assign(T &dest, const U &source) { dest = static_cast(source); } class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 : public ::testing::Test { - public: +public: Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0() { - assign(test_msg_.atmo_corr_time.tow, 365); - assign(test_msg_.atmo_corr_time.wn, 6); + assign(test_msg_.iono_corr_time.tow, 365); + assign(test_msg_.iono_corr_time.wn, 6); assign(test_msg_.chain_id, 40); assign(test_msg_.obs_time.tow, 180); assign(test_msg_.obs_time.wn, 3); @@ -61,7 +60,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 } class SlowReader final : public sbp::IReader { - public: + public: SlowReader(const uint8_t *buf, uint32_t len) : sbp::IReader(), buf_{buf}, len_{len} {} @@ -88,7 +87,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 return static_cast(ctx)->read(buf, len); } - private: + private: const uint8_t *buf_; uint32_t len_; uint32_t offset_{}; @@ -96,7 +95,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 }; class Reader final : public sbp::IReader { - public: + public: Reader(const uint8_t *buf, uint32_t len) : sbp::IReader(), buf_{buf}, len_{len} {} @@ -119,14 +118,14 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 return static_cast(ctx)->read(buf, len); } - private: + private: const uint8_t *buf_; uint32_t len_; uint32_t offset_{}; }; class SlowWriter final : public sbp::IWriter { - public: + public: explicit SlowWriter(uint32_t max_len = cMaxLen) : IWriter(), max_len_{max_len} {} static constexpr uint32_t cMaxLen = SBP_MAX_FRAME_LEN; @@ -158,14 +157,14 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 return static_cast(ctx)->write(buf, len); } - private: + private: uint8_t buf_[cMaxLen]; uint32_t max_len_; uint32_t offset_{}; }; class Writer final : public sbp::IWriter { - public: + public: explicit Writer(uint32_t max_len = cMaxLen) : IWriter(), max_len_{max_len} {} static constexpr uint32_t cMaxLen = SBP_MAX_FRAME_LEN; @@ -197,7 +196,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 return static_cast(ctx)->write(buf, len); } - private: + private: uint8_t buf_[cMaxLen]; uint32_t max_len_; uint32_t offset_{}; @@ -214,7 +213,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 std::vector outputs{}; - protected: + protected: void handle_sbp_msg(uint16_t sender_id, const sbp_msg_ssr_flag_high_level_t &msg) override { outputs.emplace_back(); @@ -238,7 +237,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 std::vector outputs{}; - private: + private: void callback(uint16_t sender_id, sbp_msg_type_t msg_type, const sbp_msg_t *msg) { ASSERT_EQ(msg_type, SbpMsgSsrFlagHighLevel); @@ -308,7 +307,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 return info; } - protected: +protected: void comparison_tests(const sbp_msg_ssr_flag_high_level_t &lesser, const sbp_msg_ssr_flag_high_level_t &greater) { sbp_msg_t wrapped_lesser = @@ -401,7 +400,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 } } - private: +private: sbp_msg_ssr_flag_high_level_t test_msg_{}; uint8_t encoded_frame_[37 + 8] = { 85, 186, 11, 66, 0, 37, 180, 0, 0, 0, 3, 0, 109, 1, 0, @@ -666,13 +665,13 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, Comparison) { { sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; sbp_msg_ssr_flag_high_level_t greater = info.test_msg; - make_lesser_greater(lesser.atmo_corr_time.tow, greater.atmo_corr_time.tow); + make_lesser_greater(lesser.iono_corr_time.tow, greater.iono_corr_time.tow); comparison_tests(lesser, greater); } { sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; sbp_msg_ssr_flag_high_level_t greater = info.test_msg; - make_lesser_greater(lesser.atmo_corr_time.wn, greater.atmo_corr_time.wn); + make_lesser_greater(lesser.iono_corr_time.wn, greater.iono_corr_time.wn); comparison_tests(lesser, greater); } { @@ -959,4 +958,4 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, EXPECT_EQ(memcmp(writer.data(), info.encoded_frame, info.frame_len), 0); } -} // namespace +} // namespace diff --git a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java index 5c86bd1a6..8f3a9da16 100644 --- a/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java +++ b/java/test/auto_check_sbp_integrity_MsgSsrFlagHighLevelTest.java @@ -40,17 +40,17 @@ public void test1() throws Throwable { JSONObject json = msg.toJSON(); Number value; Number expected; - value = msg.atmo_corr_time.tow; + value = msg.iono_corr_time.tow; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue("'" + msg.atmo_corr_time.tow + "' != '" + 365 + "'", value.equals(BigInteger.valueOf( 365L ) ) ); + org.junit.Assert.assertTrue("'" + msg.iono_corr_time.tow + "' != '" + 365 + "'", value.equals(BigInteger.valueOf( 365L ) ) ); } else { value = value.longValue(); expected = 365L; org.junit.Assert.assertEquals(value, expected); } - value = msg.atmo_corr_time.wn; + value = msg.iono_corr_time.wn; if (value instanceof BigInteger) { - org.junit.Assert.assertTrue("'" + msg.atmo_corr_time.wn + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); + org.junit.Assert.assertTrue("'" + msg.iono_corr_time.wn + "' != '" + 6 + "'", value.equals(BigInteger.valueOf( 6L ) ) ); } else { value = value.longValue(); expected = 6L; diff --git a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs index b64d7127b..6a735022e 100644 --- a/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs +++ b/rust/sbp/tests/integration/auto_check_sbp_integrity_msg_ssr_flag_high_level.rs @@ -46,14 +46,14 @@ fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { "incorrect sender id, expected 0x0042, is {sender_id}" ); assert_eq!( - msg.atmo_corr_time.tow, 365, - "incorrect value for atmo_corr_time.tow, expected 365, is {}", - msg.atmo_corr_time.tow + msg.iono_corr_time.tow, 365, + "incorrect value for iono_corr_time.tow, expected 365, is {}", + msg.iono_corr_time.tow ); assert_eq!( - msg.atmo_corr_time.wn, 6, - "incorrect value for atmo_corr_time.wn, expected 6, is {}", - msg.atmo_corr_time.wn + msg.iono_corr_time.wn, 6, + "incorrect value for iono_corr_time.wn, expected 6, is {}", + msg.iono_corr_time.wn ); assert_eq!( msg.chain_id, 40, @@ -179,7 +179,7 @@ fn test_auto_check_sbp_integrity_msg_ssr_flag_high_level() { #[cfg(feature = "json")] fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level() { { - let json_input = r#"{"obs_time": {"tow": 180, "wn": 3}, "sat_corr_time": {"tow": 360, "wn": 6}, "atmo_corr_time": {"tow": 365, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, "preamble": 85, "msg_type": 3002, "sender": 66, "length": 37, "payload": "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 61105}"#.as_bytes(); + let json_input = r#"{"obs_time": {"tow": 180, "wn": 3}, "sat_corr_time": {"tow": 360, "wn": 6}, "iono_corr_time": {"tow": 365, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, "preamble": 85, "msg_type": 3002, "sender": 66, "length": 37, "payload": "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 61105}"#.as_bytes(); let sbp_msg = { // JSON to SBP message from payload @@ -212,14 +212,14 @@ fn test_json2sbp_auto_check_sbp_integrity_msg_ssr_flag_high_level() { "incorrect sender id, expected 0x0042, is {sender_id}" ); assert_eq!( - msg.atmo_corr_time.tow, 365, - "incorrect value for atmo_corr_time.tow, expected 365, is {}", - msg.atmo_corr_time.tow + msg.iono_corr_time.tow, 365, + "incorrect value for iono_corr_time.tow, expected 365, is {}", + msg.iono_corr_time.tow ); assert_eq!( - msg.atmo_corr_time.wn, 6, - "incorrect value for atmo_corr_time.wn, expected 6, is {}", - msg.atmo_corr_time.wn + msg.iono_corr_time.wn, 6, + "incorrect value for iono_corr_time.wn, expected 6, is {}", + msg.iono_corr_time.wn ); assert_eq!( msg.chain_id, 40, @@ -386,14 +386,14 @@ fn test_sbp2json_auto_check_sbp_integrity_msg_ssr_flag_high_level() { "incorrect sender id, expected 0x0042, is {sender_id}" ); assert_eq!( - msg.atmo_corr_time.tow, 365, - "incorrect value for atmo_corr_time.tow, expected 365, is {}", - msg.atmo_corr_time.tow + msg.iono_corr_time.tow, 365, + "incorrect value for iono_corr_time.tow, expected 365, is {}", + msg.iono_corr_time.tow ); assert_eq!( - msg.atmo_corr_time.wn, 6, - "incorrect value for atmo_corr_time.wn, expected 6, is {}", - msg.atmo_corr_time.wn + msg.iono_corr_time.wn, 6, + "incorrect value for iono_corr_time.wn, expected 6, is {}", + msg.iono_corr_time.wn ); assert_eq!( msg.chain_id, 40, diff --git a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml index f56b1e4e8..16710efd9 100644 --- a/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml +++ b/spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml @@ -10,7 +10,7 @@ tests: sat_corr_time: tow: 360 wn: 6 - atmo_corr_time: + iono_corr_time: tow: 365 wn: 6 ssr_sol_id: 10 @@ -35,7 +35,7 @@ tests: name: MsgSsrFlagHighLevel msg_type: "3002" raw_json: - '{"obs_time": {"tow": 180, "wn": 3}, "sat_corr_time": {"tow": 360, "wn": 6}, "atmo_corr_time": {"tow": 365, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, + '{"obs_time": {"tow": 180, "wn": 3}, "sat_corr_time": {"tow": 360, "wn": 6}, "iono_corr_time": {"tow": 365, "wn": 6}, "ssr_sol_id": 10, "tile_set_id": 20, "tile_id": 30, "chain_id": 40, "use_gps_sat": 1, "use_gal_sat": 2, "use_bds_sat": 3, "use_qzss_sat": 4, "reserved": [0,0,0,0,0], "use_tropo_grid_points": 5, "use_iono_grid_points": 6, "use_iono_tile_sat_los": 7, "use_iono_grid_point_sat_los": 8, "preamble": 85, "msg_type": 3002, "sender": 66, "length": 37, "payload": "tAAAAAMAbQEAAAYAaAEAAAYAChQAHgAoAQIDBAAAAAAABQYHCA==", "crc": 61105}' From 7f4245e312665e99ebeb4085e822d1520ba3a2ac Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 10:32:26 +0200 Subject: [PATCH 09/10] Formatting fixed with correct computer --- ..._check_sbp_integrity_MsgSsrFlagHighLevel.c | 16 ++++---- ...check_sbp_integrity_MsgSsrFlagHighLevel.cc | 41 ++++++++++--------- 2 files changed, 29 insertions(+), 28 deletions(-) diff --git a/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c index b927d3659..b9b9b7a16 100644 --- a/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c +++ b/c/test/auto_check_sbp_integrity_MsgSsrFlagHighLevel.c @@ -104,12 +104,12 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { sbp_msg_t test_msg; memset(&test_msg, 0, sizeof(test_msg)); + test_msg.ssr_flag_high_level.chain_id = 40; + test_msg.ssr_flag_high_level.iono_corr_time.tow = 365; test_msg.ssr_flag_high_level.iono_corr_time.wn = 6; - test_msg.ssr_flag_high_level.chain_id = 40; - test_msg.ssr_flag_high_level.obs_time.tow = 180; test_msg.ssr_flag_high_level.obs_time.wn = 3; @@ -174,6 +174,12 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { sbp_message_cmp(SbpMsgSsrFlagHighLevel, &last_msg.msg, &test_msg) == 0, "Sent and received messages did not compare equal"); + ck_assert_msg( + last_msg.msg.ssr_flag_high_level.chain_id == 40, + "incorrect value for last_msg.msg.ssr_flag_high_level.chain_id, " + "expected 40, is %" PRId64, + (int64_t)last_msg.msg.ssr_flag_high_level.chain_id); + ck_assert_msg(last_msg.msg.ssr_flag_high_level.iono_corr_time.tow == 365, "incorrect value for " "last_msg.msg.ssr_flag_high_level.iono_corr_time.tow, " @@ -186,12 +192,6 @@ START_TEST(test_auto_check_sbp_integrity_MsgSsrFlagHighLevel) { "expected 6, is %" PRId64, (int64_t)last_msg.msg.ssr_flag_high_level.iono_corr_time.wn); - ck_assert_msg( - last_msg.msg.ssr_flag_high_level.chain_id == 40, - "incorrect value for last_msg.msg.ssr_flag_high_level.chain_id, " - "expected 40, is %" PRId64, - (int64_t)last_msg.msg.ssr_flag_high_level.chain_id); - ck_assert_msg( last_msg.msg.ssr_flag_high_level.obs_time.tow == 180, "incorrect value for last_msg.msg.ssr_flag_high_level.obs_time.tow, " diff --git a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc index dc68cc71c..663b9ddac 100644 --- a/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc +++ b/c/test/cpp/auto_check_sbp_integrity_MsgSsrFlagHighLevel.cc @@ -14,24 +14,25 @@ // spec/tests/yaml/swiftnav/sbp/integrity/test_MsgSsrFlagHighLevel.yaml by // generate.py. Do not modify by hand! -#include #include #include #include #include +#include namespace { -template void assign(T &dest, const U &source) { +template +void assign(T &dest, const U &source) { dest = static_cast(source); } class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 : public ::testing::Test { -public: + public: Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0() { + assign(test_msg_.chain_id, 40); assign(test_msg_.iono_corr_time.tow, 365); assign(test_msg_.iono_corr_time.wn, 6); - assign(test_msg_.chain_id, 40); assign(test_msg_.obs_time.tow, 180); assign(test_msg_.obs_time.wn, 3); @@ -60,7 +61,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 } class SlowReader final : public sbp::IReader { - public: + public: SlowReader(const uint8_t *buf, uint32_t len) : sbp::IReader(), buf_{buf}, len_{len} {} @@ -87,7 +88,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 return static_cast(ctx)->read(buf, len); } - private: + private: const uint8_t *buf_; uint32_t len_; uint32_t offset_{}; @@ -95,7 +96,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 }; class Reader final : public sbp::IReader { - public: + public: Reader(const uint8_t *buf, uint32_t len) : sbp::IReader(), buf_{buf}, len_{len} {} @@ -118,14 +119,14 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 return static_cast(ctx)->read(buf, len); } - private: + private: const uint8_t *buf_; uint32_t len_; uint32_t offset_{}; }; class SlowWriter final : public sbp::IWriter { - public: + public: explicit SlowWriter(uint32_t max_len = cMaxLen) : IWriter(), max_len_{max_len} {} static constexpr uint32_t cMaxLen = SBP_MAX_FRAME_LEN; @@ -157,14 +158,14 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 return static_cast(ctx)->write(buf, len); } - private: + private: uint8_t buf_[cMaxLen]; uint32_t max_len_; uint32_t offset_{}; }; class Writer final : public sbp::IWriter { - public: + public: explicit Writer(uint32_t max_len = cMaxLen) : IWriter(), max_len_{max_len} {} static constexpr uint32_t cMaxLen = SBP_MAX_FRAME_LEN; @@ -196,7 +197,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 return static_cast(ctx)->write(buf, len); } - private: + private: uint8_t buf_[cMaxLen]; uint32_t max_len_; uint32_t offset_{}; @@ -213,7 +214,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 std::vector outputs{}; - protected: + protected: void handle_sbp_msg(uint16_t sender_id, const sbp_msg_ssr_flag_high_level_t &msg) override { outputs.emplace_back(); @@ -237,7 +238,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 std::vector outputs{}; - private: + private: void callback(uint16_t sender_id, sbp_msg_type_t msg_type, const sbp_msg_t *msg) { ASSERT_EQ(msg_type, SbpMsgSsrFlagHighLevel); @@ -307,7 +308,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 return info; } -protected: + protected: void comparison_tests(const sbp_msg_ssr_flag_high_level_t &lesser, const sbp_msg_ssr_flag_high_level_t &greater) { sbp_msg_t wrapped_lesser = @@ -400,7 +401,7 @@ class Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0 } } -private: + private: sbp_msg_ssr_flag_high_level_t test_msg_{}; uint8_t encoded_frame_[37 + 8] = { 85, 186, 11, 66, 0, 37, 180, 0, 0, 0, 3, 0, 109, 1, 0, @@ -665,19 +666,19 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, Comparison) { { sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; sbp_msg_ssr_flag_high_level_t greater = info.test_msg; - make_lesser_greater(lesser.iono_corr_time.tow, greater.iono_corr_time.tow); + make_lesser_greater(lesser.chain_id, greater.chain_id); comparison_tests(lesser, greater); } { sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; sbp_msg_ssr_flag_high_level_t greater = info.test_msg; - make_lesser_greater(lesser.iono_corr_time.wn, greater.iono_corr_time.wn); + make_lesser_greater(lesser.iono_corr_time.tow, greater.iono_corr_time.tow); comparison_tests(lesser, greater); } { sbp_msg_ssr_flag_high_level_t lesser = info.test_msg; sbp_msg_ssr_flag_high_level_t greater = info.test_msg; - make_lesser_greater(lesser.chain_id, greater.chain_id); + make_lesser_greater(lesser.iono_corr_time.wn, greater.iono_corr_time.wn); comparison_tests(lesser, greater); } { @@ -958,4 +959,4 @@ TEST_F(Testauto_check_sbp_integrity_MsgSsrFlagHighLevel0, EXPECT_EQ(memcmp(writer.data(), info.encoded_frame, info.frame_len), 0); } -} // namespace +} // namespace From ba3233d20900191d151c3f943bbb59720891b789 Mon Sep 17 00:00:00 2001 From: Arnaud Mallen Date: Fri, 18 Jul 2025 10:42:35 +0200 Subject: [PATCH 10/10] Update all workflows --- .github/workflows/haskell.yaml | 2 +- .github/workflows/java.yaml | 21 +-------------------- .github/workflows/javascript.yaml | 2 +- .github/workflows/test_validate.yaml | 2 +- .github/workflows/validate.yaml | 10 +++++----- 5 files changed, 9 insertions(+), 28 deletions(-) diff --git a/.github/workflows/haskell.yaml b/.github/workflows/haskell.yaml index cde4e1d08..98f1707d9 100644 --- a/.github/workflows/haskell.yaml +++ b/.github/workflows/haskell.yaml @@ -14,7 +14,7 @@ on: jobs: build: name: Build - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v4 diff --git a/.github/workflows/java.yaml b/.github/workflows/java.yaml index db4965754..89bc60ae3 100644 --- a/.github/workflows/java.yaml +++ b/.github/workflows/java.yaml @@ -14,7 +14,7 @@ on: jobs: tests-java-1_8: name: Test - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v4 - uses: gradle/gradle-build-action@v3 @@ -22,22 +22,3 @@ jobs: gradle-version: 7.1.1 - name: Run tests run: make test-java - -# sonarqube: -# name: SonarQube -# runs-on: ubuntu-20.04 -# steps: -# - uses: actions/checkout@v4 -# with: -# fetch-depth: 0 -# - uses: gradle/gradle-build-action@v3 -# with: -# gradle-version: 7.1.1 -# - name: Run tests -# run: make test-java -# -# - name: Run sonarqube -# env: -# GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} -# SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} -# run: (cd java && gradle sonarqube) diff --git a/.github/workflows/javascript.yaml b/.github/workflows/javascript.yaml index 4a5135aa9..9e38a85c1 100644 --- a/.github/workflows/javascript.yaml +++ b/.github/workflows/javascript.yaml @@ -17,7 +17,7 @@ on: jobs: coverage: name: Test - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v4 diff --git a/.github/workflows/test_validate.yaml b/.github/workflows/test_validate.yaml index c0e513c85..15631c60a 100644 --- a/.github/workflows/test_validate.yaml +++ b/.github/workflows/test_validate.yaml @@ -8,7 +8,7 @@ on: jobs: test_validation: - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 steps: - name: Checkout Sources uses: actions/checkout@v4 diff --git a/.github/workflows/validate.yaml b/.github/workflows/validate.yaml index 0fa6ec904..36476ae7d 100644 --- a/.github/workflows/validate.yaml +++ b/.github/workflows/validate.yaml @@ -6,17 +6,17 @@ on: - "spec/**" push: branches: - - 'v*-release' - - 'starling-v*-release' - - 'libsbp-v*-release' + - "v*-release" + - "starling-v*-release" + - "libsbp-v*-release" tags: - - 'v*' + - "v*" paths: - "spec/**" jobs: validation: - runs-on: ubuntu-20.04 + runs-on: ubuntu-24.04 steps: - name: Checkout Current Spec uses: actions/checkout@v4