@Test
    public void test() {
        class Results {
            final DateTimeFormatter ZONED_ISO_DATE_TIME_FORMATTER = new DateTimeFormatterBuilder().appendYear(4, 4)
                .appendLiteral('-')
                .appendMonthOfYear(2)
                .appendLiteral('-')
                .appendDayOfMonth(2)
                .appendLiteral('T')
                .appendHourOfDay(2)
                .appendLiteral(':')
                .appendMinuteOfHour(2)
                .appendLiteral(':')
                .appendSecondOfMinute(2)
                .appendLiteral('.')
                .appendFractionOfSecond(0, 9)
                .appendTimeZoneOffset("Z", true, 2, 2)
                .appendOptional(new DateTimeFormatterBuilder().appendLiteral('[')
                    .appendTimeZoneId()
                    .appendLiteral(']')
                    .toParser())
                .toFormatter();

            final DateTimeFormatter ZONED_ISO_DATE_TIME_PRINTER = new DateTimeFormatterBuilder().appendYear(4, 4)
                .appendLiteral('-')
                .appendMonthOfYear(2)
                .appendLiteral('-')
                .appendDayOfMonth(2)
                .appendLiteral('T')
                .appendHourOfDay(2)
                .appendLiteral(':')
                .appendMinuteOfHour(2)
                .appendLiteral(':')
                .appendSecondOfMinute(2)
                .appendLiteral('.')
                .appendFractionOfSecond(0, 9)
                .appendTimeZoneOffset("Z", true, 2, 2)
                .appendLiteral('[')
                .appendTimeZoneId()
                .appendLiteral(']')
                .toFormatter();

            final ZoneId zoneId;

            final ZonedDateTime zonedDateTime;

            final String zonedDateTimeAsString;

            DateTime dateTime;

            String dateTimeAsString;

            String toDateTimeError;

            ZonedDateTime zonedDateTimeFromDateTime;

            String toZonedDateTimeError;

            Boolean roundTripEquals;

            Boolean roundTripIsEquals;

            Results(ZoneId zoneId) {
                this.zoneId = zoneId;
                this.zonedDateTime = ZonedDateTime.now(zoneId);
                this.zonedDateTimeAsString = this.zonedDateTime.toString();
                this.toDateTime();
                this.fromDateTime();
            }

            private void fromDateTime() {

                if (this.dateTime != null) {

                    try {
                        this.zonedDateTimeFromDateTime = ZonedDateTime.parse(this.dateTimeAsString);
                        this.roundTripEquals = this.zonedDateTime.equals(this.zonedDateTimeFromDateTime);
                        this.roundTripIsEquals = this.zonedDateTime.isEqual(this.zonedDateTimeFromDateTime);

                    } catch (Exception e) {
                        this.toZonedDateTimeError = e.getMessage();
                    }
                }
            }

            void toDateTime() {
                try {
                    this.dateTime = this.ZONED_ISO_DATE_TIME_FORMATTER.parseDateTime(this.zonedDateTimeAsString);
                    this.dateTimeAsString = this.dateTime.toString(this.ZONED_ISO_DATE_TIME_PRINTER);
                } catch (Exception e) {
                    this.toDateTimeError = e.getMessage();
                }
            }

            public boolean failedToTranslation() {
                return !(this.toDateTimeError == null && this.toZonedDateTimeError == null);
            }

            public boolean equalityFailed() {
                return !this.failedToTranslation() && (!(this.roundTripEquals || this.roundTripIsEquals));
            }

            @Override
            public String toString() {
                return new StringBuilder().append(this.zoneId)
                    .append('-')
                    .append('[')
                    .append(this.failedToTranslation() ? "translation: failed" : "translation: passed")
                    .append(this.roundTripEquals != null ? this.equalityFailed() ? ", equality: failed"
                            : ", equality: passed" : "")
                    .append(']')
                    .append("\n\n\t")
                    .append("ZonedDateTime: ")
                    .append(this.zonedDateTimeAsString)
                    .append("\n\t")
                    .append(Optional.ofNullable(this.dateTime)
                        .map(dt -> "DateTime: " + this.dateTime)
                        .orElseGet(() -> "ZoneDateTime to DateTime error: " + this.toDateTimeError))
                    .append(Optional.ofNullable(this.dateTimeAsString)
                        .map(dts -> "\n\tDateTime As ISO String: " + dts)
                        .orElse(""))
                    .append(Optional.ofNullable(this.zonedDateTimeFromDateTime)
                        .map(rd -> "\n\tZonedDateTime from DateTime: " + rd)
                        .orElse(""))
                    .append(Optional.ofNullable(this.roundTripEquals)
                        .map(b -> "\n\tRound Trip ZonedDateTime equals: " + b)
                        .orElse(""))
                    .append(Optional.ofNullable(this.roundTripIsEquals)
                        .map(b -> "\n\tRound Trip ZonedDateTime isEquals: " + b)
                        .orElse(""))
                    .append(Optional.ofNullable(this.toZonedDateTimeError)
                        .map(err -> "\n\tDateTime to ZonedDateTime error: " + err)
                        .orElse(""))
                    .append("\n\n")
                    .toString();

            }
        }

        List<Results> results = Stream.of(TimeZone.getAvailableIDs())
            .map(TimeZone::getTimeZone)
            .map(TimeZone::toZoneId)
            .map(Results::new)
            .collect(Collectors.toList());

        System.out.println("Total Count: " + results.stream()
            .count());

        System.out.println("Translation success Count: " + results.stream()
            .filter(r -> !r.failedToTranslation())
            .count());

        System.out.println("Translation failed Count: " + results.stream()
            .filter(r -> r.failedToTranslation())
            .count());

        System.out.println("Equality success Count: " + results.stream()
            .filter(r -> !r.equalityFailed() && !r.failedToTranslation())
            .count());

        System.out.println("Equality failed Count: " + results.stream()
            .filter(r -> r.equalityFailed())
            .count());

        System.out.println("Failed to translate:\n");
        results.stream()
            .filter(r -> r.failedToTranslation())
            .forEach(System.out::println);

        System.out.println("Successfully translated:\n");
        results.stream()
            .filter(r -> !r.failedToTranslation())
            .forEach(System.out::println);

        System.out.println("Failed to equality:\n");
        results.stream()
            .filter(r -> r.equalityFailed())
            .forEach(System.out::println);