guava

1
/*
2
 * Copyright (C) 2009 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.collect.testing;
18

19
import static java.util.Arrays.asList;
20

21
import com.google.common.annotations.GwtIncompatible;
22
import com.google.common.collect.testing.features.CollectionFeature;
23
import com.google.common.collect.testing.features.CollectionSize;
24
import com.google.common.collect.testing.features.MapFeature;
25
import com.google.common.collect.testing.testers.MapEntrySetTester;
26
import java.io.Serializable;
27
import java.lang.reflect.Method;
28
import java.util.Collection;
29
import java.util.Collections;
30
import java.util.Comparator;
31
import java.util.EnumMap;
32
import java.util.HashMap;
33
import java.util.Hashtable;
34
import java.util.LinkedHashMap;
35
import java.util.Map;
36
import java.util.Map.Entry;
37
import java.util.NavigableMap;
38
import java.util.SortedMap;
39
import java.util.TreeMap;
40
import java.util.concurrent.ConcurrentHashMap;
41
import java.util.concurrent.ConcurrentSkipListMap;
42
import junit.framework.Test;
43
import junit.framework.TestSuite;
44

45
/**
46
 * Generates a test suite covering the {@link Map} implementations in the {@link java.util} package.
47
 * Can be subclassed to specify tests that should be suppressed.
48
 *
49
 * @author Kevin Bourrillion
50
 */
51
@GwtIncompatible
52
public class TestsForMapsInJavaUtil {
53

54
  public static Test suite() {
55
    return new TestsForMapsInJavaUtil().allTests();
56
  }
57

58
  public Test allTests() {
59
    TestSuite suite = new TestSuite("java.util Maps");
60
    suite.addTest(testsForCheckedMap());
61
    suite.addTest(testsForCheckedNavigableMap());
62
    suite.addTest(testsForCheckedSortedMap());
63
    suite.addTest(testsForEmptyMap());
64
    suite.addTest(testsForEmptyNavigableMap());
65
    suite.addTest(testsForEmptySortedMap());
66
    suite.addTest(testsForSingletonMap());
67
    suite.addTest(testsForHashMap());
68
    suite.addTest(testsForHashtable());
69
    suite.addTest(testsForLinkedHashMap());
70
    suite.addTest(testsForSynchronizedNavigableMap());
71
    suite.addTest(testsForTreeMapNatural());
72
    suite.addTest(testsForTreeMapWithComparator());
73
    suite.addTest(testsForUnmodifiableMap());
74
    suite.addTest(testsForUnmodifiableNavigableMap());
75
    suite.addTest(testsForUnmodifiableSortedMap());
76
    suite.addTest(testsForEnumMap());
77
    suite.addTest(testsForConcurrentHashMap());
78
    suite.addTest(testsForConcurrentSkipListMapNatural());
79
    suite.addTest(testsForConcurrentSkipListMapWithComparator());
80
    return suite;
81
  }
82

83
  protected Collection<Method> suppressForCheckedMap() {
84
    return Collections.emptySet();
85
  }
86

87
  protected Collection<Method> suppressForCheckedNavigableMap() {
88
    return Collections.emptySet();
89
  }
90

91
  protected Collection<Method> suppressForCheckedSortedMap() {
92
    return Collections.emptySet();
93
  }
94

95
  protected Collection<Method> suppressForEmptyMap() {
96
    return Collections.emptySet();
97
  }
98

99
  private Collection<Method> suppressForEmptyNavigableMap() {
100
    return Collections.emptySet();
101
  }
102

103
  private Collection<Method> suppressForEmptySortedMap() {
104
    return Collections.emptySet();
105
  }
106

107
  protected Collection<Method> suppressForSingletonMap() {
108
    return Collections.emptySet();
109
  }
110

111
  protected Collection<Method> suppressForHashMap() {
112
    return Collections.emptySet();
113
  }
114

115
  protected Collection<Method> suppressForHashtable() {
116
    return Collections.emptySet();
117
  }
118

119
  protected Collection<Method> suppressForLinkedHashMap() {
120
    return Collections.emptySet();
121
  }
122

123
  protected Collection<Method> suppressForSynchronizedNavigableMap() {
124
    return Collections.emptySet();
125
  }
126

127
  protected Collection<Method> suppressForTreeMapNatural() {
128
    return Collections.emptySet();
129
  }
130

131
  protected Collection<Method> suppressForTreeMapWithComparator() {
132
    return Collections.emptySet();
133
  }
134

135
  protected Collection<Method> suppressForUnmodifiableMap() {
136
    return Collections.emptySet();
137
  }
138

139
  protected Collection<Method> suppressForUnmodifiableNavigableMap() {
140
    return Collections.emptySet();
141
  }
142

143
  protected Collection<Method> suppressForUnmodifiableSortedMap() {
144
    return Collections.emptySet();
145
  }
146

147
  protected Collection<Method> suppressForEnumMap() {
148
    return Collections.emptySet();
149
  }
150

151
  protected Collection<Method> suppressForConcurrentHashMap() {
152
    return Collections.emptySet();
153
  }
154

155
  protected Collection<Method> suppressForConcurrentSkipListMap() {
156
    return asList(
157
        MapEntrySetTester.getSetValueMethod(),
158
        MapEntrySetTester.getSetValueWithNullValuesAbsentMethod(),
159
        MapEntrySetTester.getSetValueWithNullValuesPresentMethod());
160
  }
161

162
  public Test testsForCheckedMap() {
163
    return MapTestSuiteBuilder.using(
164
            new TestStringMapGenerator() {
165
              @Override
166
              protected Map<String, String> create(Entry<String, String>[] entries) {
167
                Map<String, String> map = populate(new HashMap<String, String>(), entries);
168
                return Collections.checkedMap(map, String.class, String.class);
169
              }
170
            })
171
        .named("checkedMap/HashMap")
172
        .withFeatures(
173
            MapFeature.GENERAL_PURPOSE,
174
            MapFeature.ALLOWS_NULL_KEYS,
175
            MapFeature.ALLOWS_NULL_VALUES,
176
            MapFeature.ALLOWS_ANY_NULL_QUERIES,
177
            MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
178
            MapFeature.RESTRICTS_KEYS,
179
            MapFeature.RESTRICTS_VALUES,
180
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
181
            CollectionFeature.SERIALIZABLE,
182
            CollectionSize.ANY)
183
        .suppressing(suppressForCheckedMap())
184
        .createTestSuite();
185
  }
186

187
  public Test testsForCheckedNavigableMap() {
188
    return SortedMapTestSuiteBuilder.using(
189
            new TestStringSortedMapGenerator() {
190
              @Override
191
              protected NavigableMap<String, String> create(Entry<String, String>[] entries) {
192
                NavigableMap<String, String> map = populate(new TreeMap<String, String>(), entries);
193
                return Collections.checkedNavigableMap(map, String.class, String.class);
194
              }
195
            })
196
        .named("checkedNavigableMap/TreeMap, natural")
197
        .withFeatures(
198
            MapFeature.GENERAL_PURPOSE,
199
            MapFeature.ALLOWS_NULL_VALUES,
200
            MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
201
            MapFeature.RESTRICTS_KEYS,
202
            MapFeature.RESTRICTS_VALUES,
203
            CollectionFeature.KNOWN_ORDER,
204
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
205
            CollectionFeature.SERIALIZABLE,
206
            CollectionSize.ANY)
207
        .suppressing(suppressForCheckedNavigableMap())
208
        .createTestSuite();
209
  }
210

211
  public Test testsForCheckedSortedMap() {
212
    return SortedMapTestSuiteBuilder.using(
213
            new TestStringSortedMapGenerator() {
214
              @Override
215
              protected SortedMap<String, String> create(Entry<String, String>[] entries) {
216
                SortedMap<String, String> map = populate(new TreeMap<String, String>(), entries);
217
                return Collections.checkedSortedMap(map, String.class, String.class);
218
              }
219
            })
220
        .named("checkedSortedMap/TreeMap, natural")
221
        .withFeatures(
222
            MapFeature.GENERAL_PURPOSE,
223
            MapFeature.ALLOWS_NULL_VALUES,
224
            MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
225
            MapFeature.RESTRICTS_KEYS,
226
            MapFeature.RESTRICTS_VALUES,
227
            CollectionFeature.KNOWN_ORDER,
228
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
229
            CollectionFeature.SERIALIZABLE,
230
            CollectionSize.ANY)
231
        .suppressing(suppressForCheckedSortedMap())
232
        .createTestSuite();
233
  }
234

235
  public Test testsForEmptyMap() {
236
    return MapTestSuiteBuilder.using(
237
            new TestStringMapGenerator() {
238
              @Override
239
              protected Map<String, String> create(Entry<String, String>[] entries) {
240
                return Collections.emptyMap();
241
              }
242
            })
243
        .named("emptyMap")
244
        .withFeatures(CollectionFeature.SERIALIZABLE, CollectionSize.ZERO)
245
        .suppressing(suppressForEmptyMap())
246
        .createTestSuite();
247
  }
248

249
  public Test testsForEmptyNavigableMap() {
250
    return MapTestSuiteBuilder.using(
251
            new TestStringSortedMapGenerator() {
252
              @Override
253
              protected NavigableMap<String, String> create(Entry<String, String>[] entries) {
254
                return Collections.emptyNavigableMap();
255
              }
256
            })
257
        .named("emptyNavigableMap")
258
        .withFeatures(CollectionFeature.SERIALIZABLE, CollectionSize.ZERO)
259
        .suppressing(suppressForEmptyNavigableMap())
260
        .createTestSuite();
261
  }
262

263
  public Test testsForEmptySortedMap() {
264
    return MapTestSuiteBuilder.using(
265
            new TestStringSortedMapGenerator() {
266
              @Override
267
              protected SortedMap<String, String> create(Entry<String, String>[] entries) {
268
                return Collections.emptySortedMap();
269
              }
270
            })
271
        .named("emptySortedMap")
272
        .withFeatures(CollectionFeature.SERIALIZABLE, CollectionSize.ZERO)
273
        .suppressing(suppressForEmptySortedMap())
274
        .createTestSuite();
275
  }
276

277
  public Test testsForSingletonMap() {
278
    return MapTestSuiteBuilder.using(
279
            new TestStringMapGenerator() {
280
              @Override
281
              protected Map<String, String> create(Entry<String, String>[] entries) {
282
                return Collections.singletonMap(entries[0].getKey(), entries[0].getValue());
283
              }
284
            })
285
        .named("singletonMap")
286
        .withFeatures(
287
            MapFeature.ALLOWS_NULL_KEYS,
288
            MapFeature.ALLOWS_NULL_VALUES,
289
            MapFeature.ALLOWS_ANY_NULL_QUERIES,
290
            CollectionFeature.SERIALIZABLE,
291
            CollectionSize.ONE)
292
        .suppressing(suppressForSingletonMap())
293
        .createTestSuite();
294
  }
295

296
  public Test testsForHashMap() {
297
    return MapTestSuiteBuilder.using(
298
            new TestStringMapGenerator() {
299
              @Override
300
              protected Map<String, String> create(Entry<String, String>[] entries) {
301
                return toHashMap(entries);
302
              }
303
            })
304
        .named("HashMap")
305
        .withFeatures(
306
            MapFeature.GENERAL_PURPOSE,
307
            MapFeature.ALLOWS_NULL_KEYS,
308
            MapFeature.ALLOWS_NULL_VALUES,
309
            MapFeature.ALLOWS_ANY_NULL_QUERIES,
310
            MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
311
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
312
            CollectionFeature.SERIALIZABLE,
313
            CollectionSize.ANY)
314
        .suppressing(suppressForHashMap())
315
        .createTestSuite();
316
  }
317

318
  public Test testsForHashtable() {
319
    return MapTestSuiteBuilder.using(
320
            new TestStringMapGenerator() {
321
              @Override
322
              protected Map<String, String> create(Entry<String, String>[] entries) {
323
                return populate(new Hashtable<String, String>(), entries);
324
              }
325
            })
326
        .withFeatures(
327
            MapFeature.GENERAL_PURPOSE,
328
            MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
329
            MapFeature.RESTRICTS_KEYS,
330
            MapFeature.SUPPORTS_REMOVE,
331
            CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
332
            CollectionFeature.SERIALIZABLE,
333
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
334
            CollectionFeature.SUPPORTS_REMOVE,
335
            CollectionSize.ANY)
336
        .named("Hashtable")
337
        .suppressing(suppressForHashtable())
338
        .createTestSuite();
339
  }
340

341
  public Test testsForLinkedHashMap() {
342
    return MapTestSuiteBuilder.using(
343
            new TestStringMapGenerator() {
344
              @Override
345
              protected Map<String, String> create(Entry<String, String>[] entries) {
346
                return populate(new LinkedHashMap<String, String>(), entries);
347
              }
348
            })
349
        .named("LinkedHashMap")
350
        .withFeatures(
351
            MapFeature.GENERAL_PURPOSE,
352
            MapFeature.ALLOWS_NULL_KEYS,
353
            MapFeature.ALLOWS_NULL_VALUES,
354
            MapFeature.ALLOWS_ANY_NULL_QUERIES,
355
            MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
356
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
357
            CollectionFeature.KNOWN_ORDER,
358
            CollectionFeature.SERIALIZABLE,
359
            CollectionSize.ANY)
360
        .suppressing(suppressForLinkedHashMap())
361
        .createTestSuite();
362
  }
363

364
  /**
365
   * Tests regular NavigableMap behavior of synchronizedNavigableMap(treeMap); does not test the
366
   * fact that it's synchronized.
367
   */
368
  public Test testsForSynchronizedNavigableMap() {
369
    return NavigableMapTestSuiteBuilder.using(
370
            new TestStringSortedMapGenerator() {
371
              @Override
372
              protected SortedMap<String, String> create(Entry<String, String>[] entries) {
373
                NavigableMap<String, String> delegate = populate(new TreeMap<>(), entries);
374
                return Collections.synchronizedNavigableMap(delegate);
375
              }
376
            })
377
        .named("synchronizedNavigableMap/TreeMap, natural")
378
        .withFeatures(
379
            MapFeature.GENERAL_PURPOSE,
380
            MapFeature.ALLOWS_NULL_VALUES,
381
            MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
382
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
383
            CollectionFeature.KNOWN_ORDER,
384
            CollectionFeature.SERIALIZABLE,
385
            CollectionSize.ANY)
386
        .suppressing(suppressForSynchronizedNavigableMap())
387
        .createTestSuite();
388
  }
389

390
  public Test testsForTreeMapNatural() {
391
    return NavigableMapTestSuiteBuilder.using(
392
            new TestStringSortedMapGenerator() {
393
              @Override
394
              protected SortedMap<String, String> create(Entry<String, String>[] entries) {
395
                /*
396
                 * TODO(cpovirk): it would be nice to create an input Map and use
397
                 * the copy constructor here and in the other tests
398
                 */
399
                return populate(new TreeMap<String, String>(), entries);
400
              }
401
            })
402
        .named("TreeMap, natural")
403
        .withFeatures(
404
            MapFeature.GENERAL_PURPOSE,
405
            MapFeature.ALLOWS_NULL_VALUES,
406
            MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
407
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
408
            CollectionFeature.KNOWN_ORDER,
409
            CollectionFeature.SERIALIZABLE,
410
            CollectionSize.ANY)
411
        .suppressing(suppressForTreeMapNatural())
412
        .createTestSuite();
413
  }
414

415
  public Test testsForTreeMapWithComparator() {
416
    return NavigableMapTestSuiteBuilder.using(
417
            new TestStringSortedMapGenerator() {
418
              @Override
419
              protected SortedMap<String, String> create(Entry<String, String>[] entries) {
420
                return populate(
421
                    new TreeMap<String, String>(arbitraryNullFriendlyComparator()), entries);
422
              }
423
            })
424
        .named("TreeMap, with comparator")
425
        .withFeatures(
426
            MapFeature.GENERAL_PURPOSE,
427
            MapFeature.ALLOWS_NULL_KEYS,
428
            MapFeature.ALLOWS_NULL_VALUES,
429
            MapFeature.ALLOWS_ANY_NULL_QUERIES,
430
            MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
431
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
432
            CollectionFeature.KNOWN_ORDER,
433
            CollectionFeature.SERIALIZABLE,
434
            CollectionSize.ANY)
435
        .suppressing(suppressForTreeMapWithComparator())
436
        .createTestSuite();
437
  }
438

439
  public Test testsForUnmodifiableMap() {
440
    return MapTestSuiteBuilder.using(
441
            new TestStringMapGenerator() {
442
              @Override
443
              protected Map<String, String> create(Entry<String, String>[] entries) {
444
                return Collections.unmodifiableMap(toHashMap(entries));
445
              }
446
            })
447
        .named("unmodifiableMap/HashMap")
448
        .withFeatures(
449
            MapFeature.ALLOWS_NULL_KEYS,
450
            MapFeature.ALLOWS_NULL_VALUES,
451
            MapFeature.ALLOWS_ANY_NULL_QUERIES,
452
            CollectionFeature.SERIALIZABLE,
453
            CollectionSize.ANY)
454
        .suppressing(suppressForUnmodifiableMap())
455
        .createTestSuite();
456
  }
457

458
  public Test testsForUnmodifiableNavigableMap() {
459
    return MapTestSuiteBuilder.using(
460
            new TestStringSortedMapGenerator() {
461
              @Override
462
              protected NavigableMap<String, String> create(Entry<String, String>[] entries) {
463
                return Collections.unmodifiableNavigableMap(populate(new TreeMap<>(), entries));
464
              }
465
            })
466
        .named("unmodifiableNavigableMap/TreeMap, natural")
467
        .withFeatures(
468
            MapFeature.ALLOWS_NULL_VALUES,
469
            CollectionFeature.KNOWN_ORDER,
470
            CollectionFeature.SERIALIZABLE,
471
            CollectionSize.ANY)
472
        .suppressing(suppressForUnmodifiableNavigableMap())
473
        .createTestSuite();
474
  }
475

476
  public Test testsForUnmodifiableSortedMap() {
477
    return MapTestSuiteBuilder.using(
478
            new TestStringSortedMapGenerator() {
479
              @Override
480
              protected SortedMap<String, String> create(Entry<String, String>[] entries) {
481
                SortedMap<String, String> map = populate(new TreeMap<String, String>(), entries);
482
                return Collections.unmodifiableSortedMap(map);
483
              }
484
            })
485
        .named("unmodifiableSortedMap/TreeMap, natural")
486
        .withFeatures(
487
            MapFeature.ALLOWS_NULL_VALUES,
488
            CollectionFeature.KNOWN_ORDER,
489
            CollectionFeature.SERIALIZABLE,
490
            CollectionSize.ANY)
491
        .suppressing(suppressForUnmodifiableSortedMap())
492
        .createTestSuite();
493
  }
494

495
  public Test testsForEnumMap() {
496
    return MapTestSuiteBuilder.using(
497
            new TestEnumMapGenerator() {
498
              @Override
499
              protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
500
                return populate(new EnumMap<AnEnum, String>(AnEnum.class), entries);
501
              }
502
            })
503
        .named("EnumMap")
504
        .withFeatures(
505
            MapFeature.GENERAL_PURPOSE,
506
            MapFeature.ALLOWS_NULL_VALUES,
507
            MapFeature.RESTRICTS_KEYS,
508
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
509
            CollectionFeature.KNOWN_ORDER,
510
            CollectionFeature.SERIALIZABLE,
511
            CollectionSize.ANY)
512
        .suppressing(suppressForEnumMap())
513
        .createTestSuite();
514
  }
515

516
  public Test testsForConcurrentHashMap() {
517
    return MapTestSuiteBuilder.using(
518
            new TestStringMapGenerator() {
519
              @Override
520
              protected Map<String, String> create(Entry<String, String>[] entries) {
521
                return populate(new ConcurrentHashMap<String, String>(), entries);
522
              }
523
            })
524
        .named("ConcurrentHashMap")
525
        .withFeatures(
526
            MapFeature.GENERAL_PURPOSE,
527
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
528
            CollectionFeature.SERIALIZABLE,
529
            CollectionSize.ANY)
530
        .suppressing(suppressForConcurrentHashMap())
531
        .createTestSuite();
532
  }
533

534
  public Test testsForConcurrentSkipListMapNatural() {
535
    return NavigableMapTestSuiteBuilder.using(
536
            new TestStringSortedMapGenerator() {
537
              @Override
538
              protected SortedMap<String, String> create(Entry<String, String>[] entries) {
539
                return populate(new ConcurrentSkipListMap<String, String>(), entries);
540
              }
541
            })
542
        .named("ConcurrentSkipListMap, natural")
543
        .withFeatures(
544
            MapFeature.GENERAL_PURPOSE,
545
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
546
            CollectionFeature.KNOWN_ORDER,
547
            CollectionFeature.SERIALIZABLE,
548
            CollectionSize.ANY)
549
        .suppressing(suppressForConcurrentSkipListMap())
550
        .createTestSuite();
551
  }
552

553
  public Test testsForConcurrentSkipListMapWithComparator() {
554
    return NavigableMapTestSuiteBuilder.using(
555
            new TestStringSortedMapGenerator() {
556
              @Override
557
              protected SortedMap<String, String> create(Entry<String, String>[] entries) {
558
                return populate(
559
                    new ConcurrentSkipListMap<String, String>(arbitraryNullFriendlyComparator()),
560
                    entries);
561
              }
562
            })
563
        .named("ConcurrentSkipListMap, with comparator")
564
        .withFeatures(
565
            MapFeature.GENERAL_PURPOSE,
566
            CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
567
            CollectionFeature.KNOWN_ORDER,
568
            CollectionFeature.SERIALIZABLE,
569
            CollectionSize.ANY)
570
        .suppressing(suppressForConcurrentSkipListMap())
571
        .createTestSuite();
572
  }
573

574
  // TODO: IdentityHashMap, AbstractMap
575

576
  private static Map<String, String> toHashMap(Entry<String, String>[] entries) {
577
    return populate(new HashMap<String, String>(), entries);
578
  }
579

580
  // TODO: call conversion constructors or factory methods instead of using
581
  // populate() on an empty map
582
  private static <T, M extends Map<T, String>> M populate(M map, Entry<T, String>[] entries) {
583
    for (Entry<T, String> entry : entries) {
584
      map.put(entry.getKey(), entry.getValue());
585
    }
586
    return map;
587
  }
588

589
  static <T> Comparator<T> arbitraryNullFriendlyComparator() {
590
    return new NullFriendlyComparator<>();
591
  }
592

593
  private static final class NullFriendlyComparator<T> implements Comparator<T>, Serializable {
594
    @Override
595
    public int compare(T left, T right) {
596
      return String.valueOf(left).compareTo(String.valueOf(right));
597
    }
598
  }
599
}
600