| /* |
| * Copyright 2021 Google LLC |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.google.auto.value.extension.toprettystring; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| |
| import com.google.auto.value.AutoValue; |
| import com.google.auto.value.extension.toprettystring.ToPrettyStringTest.CollectionSubtypesWithFixedTypeParameters.StringList; |
| import com.google.auto.value.extension.toprettystring.ToPrettyStringTest.CollectionSubtypesWithFixedTypeParameters.StringMap; |
| import com.google.auto.value.extension.toprettystring.ToPrettyStringTest.PropertyHasToPrettyString.HasToPrettyString; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.collect.ImmutableMultimap; |
| import com.google.common.collect.Multimap; |
| import com.google.common.primitives.ImmutableIntArray; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| import javax.annotation.Nullable; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| @SuppressWarnings("AutoValueImmutableFields") |
| @RunWith(JUnit4.class) |
| public class ToPrettyStringTest { |
| @AutoValue |
| abstract static class Primitives { |
| abstract int i(); |
| |
| abstract long l(); |
| |
| abstract byte b(); |
| |
| abstract short s(); |
| |
| abstract char c(); |
| |
| abstract float f(); |
| |
| abstract double d(); |
| |
| abstract boolean bool(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void primitives() { |
| Primitives valueType = |
| new AutoValue_ToPrettyStringTest_Primitives( |
| 1, 2L, (byte) 3, (short) 4, 'C', 6.6f, 7.7, false); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "Primitives {" |
| + "\n i = 1," |
| + "\n l = 2," |
| + "\n b = 3," |
| + "\n s = 4," |
| + "\n c = C," |
| + "\n f = 6.6," |
| + "\n d = 7.7," |
| + "\n bool = false," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class PrimitiveArray { |
| @Nullable |
| @SuppressWarnings("mutable") |
| abstract long[] longs(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void primitiveArray() { |
| PrimitiveArray valueType = |
| new AutoValue_ToPrettyStringTest_PrimitiveArray(new long[] {1L, 2L, 10L, 200L}); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrimitiveArray {" |
| + "\n longs = [" |
| + "\n 1," |
| + "\n 2," |
| + "\n 10," |
| + "\n 200," |
| + "\n ]," |
| + "\n}"); |
| } |
| |
| @Test |
| public void primitiveArray_empty() { |
| PrimitiveArray valueType = new AutoValue_ToPrettyStringTest_PrimitiveArray(new long[0]); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrimitiveArray {" // force newline |
| + "\n longs = []," |
| + "\n}"); |
| } |
| |
| @Test |
| public void primitiveArray_null() { |
| PrimitiveArray valueType = new AutoValue_ToPrettyStringTest_PrimitiveArray(null); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrimitiveArray {" // force newline |
| + "\n longs = null," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class PrettyCollection { |
| @Nullable |
| abstract Collection<Object> collection(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void prettyCollection() { |
| PrettyCollection valueType = |
| new AutoValue_ToPrettyStringTest_PrettyCollection(ImmutableList.of("hello", "world")); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrettyCollection {" |
| + "\n collection = [" |
| + "\n hello," |
| + "\n world," |
| + "\n ]," |
| + "\n}"); |
| } |
| |
| @Test |
| public void prettyCollection_elementsWithNewlines() { |
| PrettyCollection valueType = |
| new AutoValue_ToPrettyStringTest_PrettyCollection( |
| ImmutableList.of("hello\nworld\nnewline")); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrettyCollection {" |
| + "\n collection = [" |
| + "\n hello" |
| + "\n world" |
| + "\n newline," |
| + "\n ]," |
| + "\n}"); |
| } |
| |
| @Test |
| public void prettyCollection_empty() { |
| PrettyCollection valueType = |
| new AutoValue_ToPrettyStringTest_PrettyCollection(ImmutableList.of()); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrettyCollection {" // force newline |
| + "\n collection = []," |
| + "\n}"); |
| } |
| |
| @Test |
| public void prettyCollection_null() { |
| PrettyCollection valueType = new AutoValue_ToPrettyStringTest_PrettyCollection(null); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrettyCollection {" // force newline |
| + "\n collection = null," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class NestedCollection { |
| @Nullable |
| abstract Collection<Collection<Object>> nestedCollection(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void nestedCollection() { |
| NestedCollection valueType = |
| new AutoValue_ToPrettyStringTest_NestedCollection( |
| Arrays.asList( |
| ImmutableList.of("hello", "world"), |
| ImmutableList.of("hello2", "world2"), |
| null, |
| Arrays.asList("not null", null))); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "NestedCollection {" |
| + "\n nestedCollection = [" |
| + "\n [" |
| + "\n hello," |
| + "\n world," |
| + "\n ]," |
| + "\n [" |
| + "\n hello2," |
| + "\n world2," |
| + "\n ]," |
| + "\n null," |
| + "\n [" |
| + "\n not null," |
| + "\n null," |
| + "\n ]," |
| + "\n ]," |
| + "\n}"); |
| } |
| |
| @Test |
| public void nestedCollection_elementsWithNewlines() { |
| NestedCollection valueType = |
| new AutoValue_ToPrettyStringTest_NestedCollection( |
| ImmutableList.of( |
| ImmutableList.of((Object) "hello\nworld\nnewline", "hello2\nworld2\nnewline2"))); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "NestedCollection {" |
| + "\n nestedCollection = [" |
| + "\n [" |
| + "\n hello" |
| + "\n world" |
| + "\n newline," |
| + "\n hello2" |
| + "\n world2" |
| + "\n newline2," |
| + "\n ]," |
| + "\n ]," |
| + "\n}"); |
| } |
| |
| @Test |
| public void nestedCollection_empty() { |
| NestedCollection valueType = |
| new AutoValue_ToPrettyStringTest_NestedCollection(ImmutableList.of()); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "NestedCollection {" // force newline |
| + "\n nestedCollection = []," |
| + "\n}"); |
| } |
| |
| @Test |
| public void nestedCollection_nestedEmpty() { |
| NestedCollection valueType = |
| new AutoValue_ToPrettyStringTest_NestedCollection( |
| ImmutableList.of(ImmutableList.of(), ImmutableList.of())); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "NestedCollection {" |
| + "\n nestedCollection = [" |
| + "\n []," |
| + "\n []," |
| + "\n ]," |
| + "\n}"); |
| } |
| |
| @Test |
| public void nestedCollection_null() { |
| NestedCollection valueType = new AutoValue_ToPrettyStringTest_NestedCollection(null); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "NestedCollection {" // force newline |
| + "\n nestedCollection = null," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class ImmutablePrimitiveArray { |
| @Nullable |
| abstract ImmutableIntArray immutableIntArray(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void immutablePrimitiveArray() { |
| ImmutablePrimitiveArray valueType = |
| new AutoValue_ToPrettyStringTest_ImmutablePrimitiveArray(ImmutableIntArray.of(1, 2)); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "ImmutablePrimitiveArray {" |
| + "\n immutableIntArray = [" |
| + "\n 1," |
| + "\n 2," |
| + "\n ]," |
| + "\n}"); |
| } |
| |
| @Test |
| public void immutablePrimitiveArray_empty() { |
| ImmutablePrimitiveArray valueType = |
| new AutoValue_ToPrettyStringTest_ImmutablePrimitiveArray(ImmutableIntArray.of()); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "ImmutablePrimitiveArray {" // force newline |
| + "\n immutableIntArray = []," |
| + "\n}"); |
| } |
| |
| @Test |
| public void immutablePrimitiveArray_null() { |
| ImmutablePrimitiveArray valueType = |
| new AutoValue_ToPrettyStringTest_ImmutablePrimitiveArray(null); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "ImmutablePrimitiveArray {" // force newline |
| + "\n immutableIntArray = null," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class PrettyMap { |
| @Nullable |
| abstract Map<Object, Object> map(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void prettyMap() { |
| PrettyMap valueType = new AutoValue_ToPrettyStringTest_PrettyMap(ImmutableMap.of(1, 2)); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrettyMap {" // force newline |
| + "\n map = {" |
| + "\n 1: 2," |
| + "\n }," |
| + "\n}"); |
| } |
| |
| @Test |
| public void prettyMap_keysAndValuesWithNewlines() { |
| PrettyMap valueType = |
| new AutoValue_ToPrettyStringTest_PrettyMap( |
| ImmutableMap.of( |
| "key1\nnewline", "value1\nnewline", "key2\nnewline", "value2\nnewline")); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrettyMap {" |
| + "\n map = {" |
| + "\n key1" |
| + "\n newline: value1" |
| + "\n newline," |
| + "\n key2" |
| + "\n newline: value2" |
| + "\n newline," |
| + "\n }," |
| + "\n}"); |
| } |
| |
| @Test |
| public void prettyMap_empty() { |
| PrettyMap valueType = new AutoValue_ToPrettyStringTest_PrettyMap(ImmutableMap.of()); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrettyMap {" // force newline |
| + "\n map = {}," |
| + "\n}"); |
| } |
| |
| @Test |
| public void prettyMap_null() { |
| PrettyMap valueType = new AutoValue_ToPrettyStringTest_PrettyMap(null); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrettyMap {" // force newline |
| + "\n map = null," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class MapOfMaps { |
| @Nullable |
| abstract Map<Map<Object, Object>, Map<Object, Object>> mapOfMaps(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| private static <K, V> Map<K, V> mapWithNulls(K k, V v) { |
| Map<K, V> map = new LinkedHashMap<>(); |
| map.put(k, v); |
| return map; |
| } |
| |
| @Test |
| public void mapOfMaps() { |
| Map<Map<Object, Object>, Map<Object, Object>> mapOfMaps = new LinkedHashMap<>(); |
| mapOfMaps.put(ImmutableMap.of("k1_k", "k1_v"), ImmutableMap.of("v1_k", "v1_v")); |
| mapOfMaps.put(ImmutableMap.of("k2_k", "k2_v"), ImmutableMap.of("v2_k", "v2_v")); |
| mapOfMaps.put(mapWithNulls("keyForNullValue", null), mapWithNulls(null, "valueForNullKey")); |
| mapOfMaps.put(null, ImmutableMap.of("nullKeyKey", "nullKeyValue")); |
| mapOfMaps.put(ImmutableMap.of("nullValueKey", "nullValueValue"), null); |
| mapOfMaps.put( |
| ImmutableMap.of("keyForMapOfNullsKey", "keyForMapOfNullsValue"), mapWithNulls(null, null)); |
| MapOfMaps valueType = new AutoValue_ToPrettyStringTest_MapOfMaps(mapOfMaps); |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "MapOfMaps {" |
| + "\n mapOfMaps = {" |
| + "\n {" |
| + "\n k1_k: k1_v," |
| + "\n }: {" |
| + "\n v1_k: v1_v," |
| + "\n }," |
| + "\n {" |
| + "\n k2_k: k2_v," |
| + "\n }: {" |
| + "\n v2_k: v2_v," |
| + "\n }," |
| + "\n {" |
| + "\n keyForNullValue: null," |
| + "\n }: {" |
| + "\n null: valueForNullKey," |
| + "\n }," |
| + "\n null: {" |
| + "\n nullKeyKey: nullKeyValue," |
| + "\n }," |
| + "\n {" |
| + "\n nullValueKey: nullValueValue," |
| + "\n }: null," |
| + "\n {" |
| + "\n keyForMapOfNullsKey: keyForMapOfNullsValue," |
| + "\n }: {" |
| + "\n null: null," |
| + "\n }," |
| + "\n }," |
| + "\n}"); |
| } |
| |
| @Test |
| public void mapOfMaps_elementsWithNewlines() { |
| MapOfMaps valueType = |
| new AutoValue_ToPrettyStringTest_MapOfMaps( |
| ImmutableMap.of( |
| ImmutableMap.of((Object) "k_k\nnewline", (Object) "k_v\nnewline"), |
| ImmutableMap.of((Object) "v_k\nnewline", (Object) "v_v\nnewline"))); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "MapOfMaps {" |
| + "\n mapOfMaps = {" |
| + "\n {" |
| + "\n k_k" |
| + "\n newline: k_v" |
| + "\n newline," |
| + "\n }: {" |
| + "\n v_k" |
| + "\n newline: v_v" |
| + "\n newline," |
| + "\n }," |
| + "\n }," |
| + "\n}"); |
| } |
| |
| @Test |
| public void mapOfMaps_empty() { |
| MapOfMaps valueType = new AutoValue_ToPrettyStringTest_MapOfMaps(ImmutableMap.of()); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "MapOfMaps {" // force newline |
| + "\n mapOfMaps = {}," |
| + "\n}"); |
| } |
| |
| @Test |
| public void mapOfMaps_nestedEmpty() { |
| MapOfMaps valueType = |
| new AutoValue_ToPrettyStringTest_MapOfMaps( |
| ImmutableMap.of(ImmutableMap.of(), ImmutableMap.of())); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "MapOfMaps {" // force newline |
| + "\n mapOfMaps = {" |
| + "\n {}: {}," |
| + "\n }," |
| + "\n}"); |
| } |
| |
| @Test |
| public void mapOfMaps_null() { |
| MapOfMaps valueType = new AutoValue_ToPrettyStringTest_MapOfMaps(null); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "MapOfMaps {" // force newline |
| + "\n mapOfMaps = null," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class PrettyMultimap { |
| @Nullable |
| abstract Multimap<Object, Object> multimap(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void prettyMultimap() { |
| PrettyMultimap valueType = |
| new AutoValue_ToPrettyStringTest_PrettyMultimap( |
| ImmutableMultimap.builder().putAll("k", "v1", "v2").build()); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrettyMultimap {" // force newline |
| + "\n multimap = {" |
| + "\n k: [" |
| + "\n v1," |
| + "\n v2," |
| + "\n ]," |
| + "\n }," |
| + "\n}"); |
| } |
| |
| @Test |
| public void prettyMultimap_keysAndValuesWithNewlines() { |
| PrettyMultimap valueType = |
| new AutoValue_ToPrettyStringTest_PrettyMultimap( |
| ImmutableMultimap.builder() |
| .putAll("key\nnewline", "value1\nnewline", "value2\nnewline") |
| .build()); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrettyMultimap {" |
| + "\n multimap = {" |
| + "\n key" |
| + "\n newline: [" |
| + "\n value1" |
| + "\n newline," |
| + "\n value2" |
| + "\n newline," |
| + "\n ]," |
| + "\n }," |
| + "\n}"); |
| } |
| |
| @Test |
| public void prettyMultimap_empty() { |
| PrettyMultimap valueType = |
| new AutoValue_ToPrettyStringTest_PrettyMultimap(ImmutableMultimap.of()); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrettyMultimap {" // force newline |
| + "\n multimap = {}," |
| + "\n}"); |
| } |
| |
| @Test |
| public void prettyMultimap_null() { |
| PrettyMultimap valueType = new AutoValue_ToPrettyStringTest_PrettyMultimap(null); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PrettyMultimap {" // force newline |
| + "\n multimap = null," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class JavaOptional { |
| @Nullable |
| abstract java.util.Optional<Object> optional(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void javaOptional_present() { |
| JavaOptional valueType = |
| new AutoValue_ToPrettyStringTest_JavaOptional(java.util.Optional.of("hello, world")); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "JavaOptional {" // force newline |
| + "\n optional = hello, world," |
| + "\n}"); |
| } |
| |
| @Test |
| public void javaOptional_empty() { |
| JavaOptional valueType = |
| new AutoValue_ToPrettyStringTest_JavaOptional(java.util.Optional.empty()); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "JavaOptional {" // force newline |
| + "\n optional = <empty>," |
| + "\n}"); |
| } |
| |
| @Test |
| public void javaOptional_valueWithNewlines() { |
| JavaOptional valueType = |
| new AutoValue_ToPrettyStringTest_JavaOptional( |
| java.util.Optional.of("optional\nwith\nnewline")); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "JavaOptional {" // force newline |
| + "\n optional = optional" |
| + "\n with" |
| + "\n newline," |
| + "\n}"); |
| } |
| |
| @Test |
| public void javaOptional_null() { |
| @SuppressWarnings("NullOptional") |
| JavaOptional valueType = new AutoValue_ToPrettyStringTest_JavaOptional(null); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "JavaOptional {" // force newline |
| + "\n optional = null," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class GuavaOptional { |
| @Nullable |
| abstract com.google.common.base.Optional<Object> optional(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void guavaOptional_present() { |
| GuavaOptional valueType = |
| new AutoValue_ToPrettyStringTest_GuavaOptional( |
| com.google.common.base.Optional.of("hello, world")); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "GuavaOptional {" // force newline |
| + "\n optional = hello, world," |
| + "\n}"); |
| } |
| |
| @Test |
| public void guavaOptional_absent() { |
| GuavaOptional valueType = |
| new AutoValue_ToPrettyStringTest_GuavaOptional(com.google.common.base.Optional.absent()); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "GuavaOptional {" // force newline |
| + "\n optional = <absent>," |
| + "\n}"); |
| } |
| |
| @Test |
| public void guavaOptional_valueWithNewlines() { |
| GuavaOptional valueType = |
| new AutoValue_ToPrettyStringTest_GuavaOptional( |
| com.google.common.base.Optional.of("optional\nwith\nnewline")); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "GuavaOptional {" // force newline |
| + "\n optional = optional" |
| + "\n with" |
| + "\n newline," |
| + "\n}"); |
| } |
| |
| @Test |
| public void guavaOptional_null() { |
| @SuppressWarnings("NullOptional") |
| GuavaOptional valueType = new AutoValue_ToPrettyStringTest_GuavaOptional(null); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "GuavaOptional {" // force newline |
| + "\n optional = null," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class NestAllTheThings { |
| @Nullable |
| abstract com.google.common.base.Optional< |
| java.util.Optional< |
| List< // open list |
| Map<ImmutableIntArray, Multimap<int[][], Object>> |
| // close list |
| >>> |
| value(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void nestAllTheThings() { |
| NestAllTheThings valueType = |
| new AutoValue_ToPrettyStringTest_NestAllTheThings( |
| com.google.common.base.Optional.of( |
| java.util.Optional.of( |
| ImmutableList.of( |
| ImmutableMap.of( |
| ImmutableIntArray.of(-1, -2, -3), |
| ImmutableMultimap.of( |
| new int[][] {{1, 2}, {3, 4, 5}, {}}, "value\nwith\nnewline")))))); |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "NestAllTheThings {" |
| + "\n value = [" |
| + "\n {" |
| + "\n [" |
| + "\n -1," |
| + "\n -2," |
| + "\n -3," |
| + "\n ]: {" |
| + "\n [" |
| + "\n [" |
| + "\n 1," |
| + "\n 2," |
| + "\n ]," |
| + "\n [" |
| + "\n 3," |
| + "\n 4," |
| + "\n 5," |
| + "\n ]," |
| + "\n []," |
| + "\n ]: [" |
| + "\n value" |
| + "\n with" |
| + "\n newline," |
| + "\n ]," |
| + "\n }," |
| + "\n }," |
| + "\n ]," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class WithCustomName { |
| abstract int i(); |
| |
| @ToPrettyString |
| abstract String customName(); |
| } |
| |
| @Test |
| public void withCustomName() { |
| WithCustomName valueType = new AutoValue_ToPrettyStringTest_WithCustomName(1); |
| |
| assertThat(valueType.customName()) |
| .isEqualTo( |
| "WithCustomName {" // force newline |
| + "\n i = 1," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class OverridesToString { |
| abstract int i(); |
| |
| @ToPrettyString |
| @Override |
| public abstract String toString(); |
| } |
| |
| @Test |
| public void overridesToString() { |
| OverridesToString valueType = new AutoValue_ToPrettyStringTest_OverridesToString(1); |
| |
| assertThat(valueType.toString()) |
| .isEqualTo( |
| "OverridesToString {" // force newline |
| + "\n i = 1," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class PropertyHasToPrettyString { |
| static class HasToPrettyString<A> { |
| @Override |
| public String toString() { |
| throw new AssertionError(); |
| } |
| |
| @ToPrettyString |
| String toPrettyString() { |
| return "custom\n@ToPrettyString\nmethod"; |
| } |
| } |
| |
| static class HasInheritedToPrettyString extends HasToPrettyString<String> {} |
| |
| interface HasToPrettyStringInInterface { |
| @ToPrettyString |
| default String toPrettyString() { |
| return "custom\n@ToPrettyString\nmethod\ninterface"; |
| } |
| } |
| |
| static class HasToPrettyStringFromSuperInterface implements HasToPrettyStringInInterface {} |
| |
| abstract HasToPrettyString<String> parameterizedWithString(); |
| |
| abstract HasToPrettyString<Void> parameterizedWithVoid(); |
| |
| abstract HasInheritedToPrettyString superclass(); |
| |
| abstract HasToPrettyStringFromSuperInterface superinterface(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void propertyHasToPrettyString() { |
| PropertyHasToPrettyString valueType = |
| new AutoValue_ToPrettyStringTest_PropertyHasToPrettyString( |
| new PropertyHasToPrettyString.HasToPrettyString<>(), |
| new PropertyHasToPrettyString.HasToPrettyString<>(), |
| new PropertyHasToPrettyString.HasInheritedToPrettyString(), |
| new PropertyHasToPrettyString.HasToPrettyStringFromSuperInterface()); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "PropertyHasToPrettyString {" |
| + "\n parameterizedWithString = custom" |
| + "\n @ToPrettyString" |
| + "\n method," |
| + "\n parameterizedWithVoid = custom" |
| + "\n @ToPrettyString" |
| + "\n method," |
| + "\n superclass = custom" |
| + "\n @ToPrettyString" |
| + "\n method," |
| + "\n superinterface = custom" |
| + "\n @ToPrettyString" |
| + "\n method" |
| + "\n interface," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class CollectionSubtypesWithFixedTypeParameters { |
| static class StringList extends ArrayList<String> {} |
| |
| static class StringMap extends LinkedHashMap<String, String> {} |
| |
| abstract StringList list(); |
| |
| abstract StringMap map(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void fixedTypeParameters() { |
| StringList stringList = new StringList(); |
| stringList.addAll(ImmutableList.of("a", "b", "c")); |
| StringMap stringMap = new StringMap(); |
| stringMap.putAll(ImmutableMap.of("A", "a", "B", "b")); |
| CollectionSubtypesWithFixedTypeParameters valueType = |
| new AutoValue_ToPrettyStringTest_CollectionSubtypesWithFixedTypeParameters( |
| stringList, stringMap); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "CollectionSubtypesWithFixedTypeParameters {" |
| + "\n list = [" |
| + "\n a," |
| + "\n b," |
| + "\n c," |
| + "\n ]," |
| + "\n map = {" |
| + "\n A: a," |
| + "\n B: b," |
| + "\n }," |
| + "\n}"); |
| } |
| |
| @AutoValue |
| abstract static class JavaBeans { |
| abstract int getInt(); |
| |
| abstract boolean isBoolean(); |
| |
| abstract String getNotAJavaIdentifier(); |
| |
| @ToPrettyString |
| abstract String toPrettyString(); |
| } |
| |
| @Test |
| public void javaBeans() { |
| JavaBeans valueType = new AutoValue_ToPrettyStringTest_JavaBeans(4, false, "not"); |
| |
| assertThat(valueType.toPrettyString()) |
| .isEqualTo( |
| "JavaBeans {" |
| + "\n int = 4," |
| + "\n boolean = false," |
| + "\n notAJavaIdentifier = not," |
| + "\n}"); |
| |
| // Check to make sure that we use the same property names that AutoValue does. This is mostly |
| // defensive, since in some scenarios AutoValue considers the property names of a java bean as |
| // having the prefix removed. |
| assertThat(valueType.toString()) |
| .isEqualTo("JavaBeans{int=4, boolean=false, notAJavaIdentifier=not}"); |
| } |
| } |
