user/test/com/google/gwt/emultest/java8/util/ComparatorTest.java

/*
 * Copyright 2016 Google Inc.
 *
 * 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.gwt.emultest.java8.util;

import com.google.gwt.emultest.java.util.EmulTestBase;

import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * Java 8 methods to test in java.util.Comparator.
 */
public class ComparatorTest extends EmulTestBase {

  public void testThenComparing() {
    Supplier<String[]> strings = () -> new String[] {"1,b", "1,a", "2,a"};
    // expected sort results for 1st and 2nd char, each (f)orward or (r)everse
    String[] f1f2 = {"1,a", "1,b", "2,a"};
    String[] f1r2 = {"1,b", "1,a", "2,a"};
    String[] f2f1 = {"1,a", "2,a" ,"1,b"};

    // keyextractor
    assertSortedEquals(f1f2, strings,
        Comparator.<String, String>comparing(s -> s.split(",")[0])
            .thenComparing(s -> s.split(",")[1])
    );
    // keyextractor, keycomparator
    assertSortedEquals(f1r2, strings,
        Comparator.<String, String>comparing(s -> s.split(",")[0])
            .thenComparing(
                s -> s.split(",")[1],
                Comparator.<String>reverseOrder()
            )
    );

    // int key extractor
    assertSortedEquals(f2f1, strings,
        Comparator.<String, String>comparing(s -> s.split(",")[1])
            .thenComparingInt(
                s -> Integer.parseInt(s.split(",")[0])
            )
    );
    // long key extractor
    assertSortedEquals(f2f1, strings,
        Comparator.<String, String>comparing(s -> s.split(",")[1])
            .thenComparingLong(
                s -> Long.parseLong(s.split(",")[0])
            )
    );
    // double key extractor
    assertSortedEquals(f2f1, strings,
        Comparator.<String, String>comparing(s -> s.split(",")[1])
            .thenComparingDouble(
                s -> Double.parseDouble(s.split(",")[0])
            )
    );
  }

  public void testComparing() {
    Supplier<String[]> strings = () -> new String[] {"1b3", "2a1", "3c2"};
    // pre-sorted lists to test against, named for which char (1-indexed) they are sorted on
    String[] first = {"1b3", "2a1", "3c2"};
    String[] second = {"2a1", "1b3", "3c2"};
    String[] third = {"2a1", "3c2", "1b3"};

    // keyextractor
    assertSortedEquals(first, strings, Comparator.comparing(Function.identity()));
    Comparator<String> comparing = Comparator.comparing(Function.identity());
    assertSortedEquals(reverse(first), strings, comparing.reversed());
    assertSortedEquals(second, strings, Comparator.comparing(a -> a.substring(1)));
    assertSortedEquals(third, strings, Comparator.comparing(a -> a.substring(2)));

    // keyextractor, keycomparator
    assertSortedEquals(reverse(second), strings, Comparator.comparing(a -> a.substring(1), Comparator.reverseOrder()));
    comparing = Comparator.comparing(a -> a.substring(1));
    assertSortedEquals(reverse(second), strings, comparing.reversed());

    // double key extractor
    comparing = Comparator.comparingDouble(a -> Double.parseDouble(a.substring(2)));
    assertSortedEquals(third, strings, comparing);
    assertSortedEquals(reverse(third), strings, comparing.reversed());
    // int key extractor
    comparing = Comparator.comparingInt(a -> Integer.parseInt(a.substring(2)));
    assertSortedEquals(third, strings, comparing);
    assertSortedEquals(reverse(third), strings, comparing.reversed());
    // long key extractor
    comparing = Comparator.comparingLong(a -> Long.parseLong(a.substring(2)));
    assertSortedEquals(third, strings, comparing);
    assertSortedEquals(reverse(third), strings, comparing.reversed());
  }

  public void testNullsFirst() {
    Supplier<String[]> strings = () -> new String[]{"a", null, "c", null, "b"};
    assertSortedEquals(
        new String[] {null, null, "a", "b", "c"},
        strings,
        Comparator.nullsFirst(Comparator.naturalOrder())
    );
    assertSortedEquals(
        new String[] {null, null, "c", "b", "a"},
        strings,
        Comparator.nullsFirst(Comparator.reverseOrder())
    );
  }

  public void testNullsLast() {
    Supplier<String[]> strings = () -> new String[]{"a", null, "c", null, "b"};
    assertSortedEquals(
        new String[] {"a", "b", "c", null, null},
        strings,
        Comparator.nullsLast(Comparator.naturalOrder())
    );
    assertSortedEquals(
        new String[] {"c", "b", "a", null, null},
        strings,
        Comparator.nullsLast(Comparator.reverseOrder())
    );
  }

  private static void assertSortedEquals(String[] expected, Supplier<String[]> presort, Comparator<String> comparator) {
    String[] presortedArray = presort.get();
    Arrays.sort(presortedArray, comparator);
    assertEquals(expected, presortedArray);
  }

  private static String[] reverse(String[] array) {
    int length = array.length;
    String[] reversed = new String[length];
    for (int i = 0, j = length - 1; i < length; ++i, --j) {
      reversed[i] = array[j];
    }
    return reversed;
  }
}