1 /*
2  * Copyright (C) 2008 The Guava Authors
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.common.base;
18 
19 import static com.google.common.base.Functions.toStringFunction;
20 
21 import com.google.common.annotations.GwtCompatible;
22 import com.google.common.collect.ImmutableList;
23 import com.google.common.collect.Lists;
24 import com.google.common.primitives.Longs;
25 import com.google.common.testing.EqualsTester;
26 import com.google.common.testing.SerializableTester;
27 import java.util.Iterator;
28 import java.util.List;
29 import junit.framework.TestCase;
30 
31 /** Unit tests for {@link Converter}. */
32 @GwtCompatible
33 public class ConverterTest extends TestCase {
34 
35   private static final Converter<String, Long> STR_TO_LONG =
36       new Converter<String, Long>() {
37         @Override
38         protected Long doForward(String object) {
39           return Long.valueOf(object);
40         }
41 
42         @Override
43         protected String doBackward(Long object) {
44           return String.valueOf(object);
45         }
46 
47         @Override
48         public String toString() {
49           return "string2long";
50         }
51       };
52 
53   private static final Long LONG_VAL = 12345L;
54   private static final String STR_VAL = "12345";
55 
56   private static final ImmutableList<String> STRINGS = ImmutableList.of("123", "456");
57   private static final ImmutableList<Long> LONGS = ImmutableList.of(123L, 456L);
58 
testConverter()59   public void testConverter() {
60     assertEquals(LONG_VAL, STR_TO_LONG.convert(STR_VAL));
61     assertEquals(STR_VAL, STR_TO_LONG.reverse().convert(LONG_VAL));
62 
63     Iterable<Long> convertedValues = STR_TO_LONG.convertAll(STRINGS);
64     assertEquals(LONGS, ImmutableList.copyOf(convertedValues));
65   }
66 
testConvertAllIsView()67   public void testConvertAllIsView() {
68     List<String> mutableList = Lists.newArrayList("789", "123");
69     Iterable<Long> convertedValues = STR_TO_LONG.convertAll(mutableList);
70     assertEquals(ImmutableList.of(789L, 123L), ImmutableList.copyOf(convertedValues));
71 
72     Iterator<Long> iterator = convertedValues.iterator();
73     iterator.next();
74     iterator.remove();
75     assertEquals(ImmutableList.of("123"), mutableList);
76   }
77 
testReverse()78   public void testReverse() {
79     Converter<Long, String> reverseConverter = STR_TO_LONG.reverse();
80 
81     assertEquals(STR_VAL, reverseConverter.convert(LONG_VAL));
82     assertEquals(LONG_VAL, reverseConverter.reverse().convert(STR_VAL));
83 
84     Iterable<String> convertedValues = reverseConverter.convertAll(LONGS);
85     assertEquals(STRINGS, ImmutableList.copyOf(convertedValues));
86 
87     assertSame(STR_TO_LONG, reverseConverter.reverse());
88 
89     assertEquals("string2long.reverse()", reverseConverter.toString());
90 
91     new EqualsTester()
92         .addEqualityGroup(STR_TO_LONG, STR_TO_LONG.reverse().reverse())
93         .addEqualityGroup(STR_TO_LONG.reverse(), STR_TO_LONG.reverse())
94         .testEquals();
95   }
96 
testReverseReverse()97   public void testReverseReverse() {
98     Converter<String, Long> converter = STR_TO_LONG;
99     assertEquals(converter, converter.reverse().reverse());
100   }
101 
testApply()102   public void testApply() {
103     assertEquals(LONG_VAL, STR_TO_LONG.apply(STR_VAL));
104   }
105 
106   private static class StringWrapper {
107     private final String value;
108 
StringWrapper(String value)109     public StringWrapper(String value) {
110       this.value = value;
111     }
112   }
113 
testAndThen()114   public void testAndThen() {
115     Converter<StringWrapper, String> first =
116         new Converter<StringWrapper, String>() {
117           @Override
118           protected String doForward(StringWrapper object) {
119             return object.value;
120           }
121 
122           @Override
123           protected StringWrapper doBackward(String object) {
124             return new StringWrapper(object);
125           }
126 
127           @Override
128           public String toString() {
129             return "StringWrapper";
130           }
131         };
132 
133     Converter<StringWrapper, Long> converter = first.andThen(STR_TO_LONG);
134 
135     assertEquals(LONG_VAL, converter.convert(new StringWrapper(STR_VAL)));
136     assertEquals(STR_VAL, converter.reverse().convert(LONG_VAL).value);
137 
138     assertEquals("StringWrapper.andThen(string2long)", converter.toString());
139 
140     assertEquals(first.andThen(STR_TO_LONG), first.andThen(STR_TO_LONG));
141   }
142 
testIdentityConverter()143   public void testIdentityConverter() {
144     Converter<String, String> stringIdentityConverter = Converter.identity();
145 
146     assertSame(stringIdentityConverter, stringIdentityConverter.reverse());
147     assertSame(STR_TO_LONG, stringIdentityConverter.andThen(STR_TO_LONG));
148 
149     assertSame(STR_VAL, stringIdentityConverter.convert(STR_VAL));
150     assertSame(STR_VAL, stringIdentityConverter.reverse().convert(STR_VAL));
151 
152     assertEquals("Converter.identity()", stringIdentityConverter.toString());
153 
154     assertSame(Converter.identity(), Converter.identity());
155   }
156 
testFrom()157   public void testFrom() {
158     Function<String, Integer> forward =
159         new Function<String, Integer>() {
160           @Override
161           public Integer apply(String input) {
162             return Integer.parseInt(input);
163           }
164         };
165     Function<Object, String> backward = toStringFunction();
166 
167     Converter<String, Number> converter = Converter.<String, Number>from(forward, backward);
168 
169     assertNull(converter.convert(null));
170     assertNull(converter.reverse().convert(null));
171 
172     assertEquals((Integer) 5, converter.convert("5"));
173     assertEquals("5", converter.reverse().convert(5));
174   }
175 
testNullIsPassedThrough()176   public void testNullIsPassedThrough() {
177     Converter<String, String> nullsArePassed = sillyConverter(false);
178     assertEquals("forward", nullsArePassed.convert("foo"));
179     assertEquals("forward", nullsArePassed.convert(null));
180     assertEquals("backward", nullsArePassed.reverse().convert("foo"));
181     assertEquals("backward", nullsArePassed.reverse().convert(null));
182   }
183 
testNullIsNotPassedThrough()184   public void testNullIsNotPassedThrough() {
185     Converter<String, String> nullsAreHandled = sillyConverter(true);
186     assertEquals("forward", nullsAreHandled.convert("foo"));
187     assertEquals(null, nullsAreHandled.convert(null));
188     assertEquals("backward", nullsAreHandled.reverse().convert("foo"));
189     assertEquals(null, nullsAreHandled.reverse().convert(null));
190   }
191 
sillyConverter(final boolean handleNullAutomatically)192   private static Converter<String, String> sillyConverter(final boolean handleNullAutomatically) {
193     return new Converter<String, String>(handleNullAutomatically) {
194       @Override
195       protected String doForward(String string) {
196         return "forward";
197       }
198 
199       @Override
200       protected String doBackward(String string) {
201         return "backward";
202       }
203     };
204   }
205 
206   public void testSerialization_identity() {
207     Converter<String, String> identityConverter = Converter.identity();
208     SerializableTester.reserializeAndAssert(identityConverter);
209   }
210 
211   public void testSerialization_reverse() {
212     Converter<Long, String> reverseConverter = Longs.stringConverter().reverse();
213     SerializableTester.reserializeAndAssert(reverseConverter);
214   }
215 
216   public void testSerialization_andThen() {
217     Converter<String, Long> converterA = Longs.stringConverter();
218     Converter<Long, String> reverseConverter = Longs.stringConverter().reverse();
219     Converter<String, String> composedConverter = converterA.andThen(reverseConverter);
220     SerializableTester.reserializeAndAssert(composedConverter);
221   }
222 
223   public void testSerialization_from() {
224     Converter<String, String> dumb = Converter.from(toStringFunction(), toStringFunction());
225     SerializableTester.reserializeAndAssert(dumb);
226   }
227 }
228