| // Copyright 2014 The Bazel Authors. All rights reserved. |
| // |
| // 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.devtools.build.lib.util; |
| |
| import static com.google.common.collect.ImmutableList.toImmutableList; |
| import static com.google.common.truth.Truth.assertThat; |
| import static org.junit.Assert.assertThrows; |
| |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.Iterables; |
| import com.google.testing.junit.testparameterinjector.TestParameter; |
| import com.google.testing.junit.testparameterinjector.TestParameterInjector; |
| import java.util.List; |
| import java.util.stream.IntStream; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| |
| /** Tests for {@link GroupedList}. */ |
| @RunWith(TestParameterInjector.class) |
| public final class GroupedListTest { |
| |
| @TestParameter private boolean withHashSet; |
| |
| private GroupedList<String> createGroupedList() { |
| if (withHashSet) { |
| return new GroupedList.WithHashSet<>(); |
| } |
| return new GroupedList<>(); |
| } |
| |
| @Test |
| public void singleGroup(@TestParameter({"0", "1", "2", "10"}) int size) { |
| GroupedList<String> groupedList = createGroupedList(); |
| ImmutableList<String> elements = |
| IntStream.range(0, size).mapToObj(String::valueOf).collect(toImmutableList()); |
| groupedList.appendGroup(elements); |
| checkGroups(groupedList, size == 0 ? ImmutableList.of() : ImmutableList.of(elements)); |
| } |
| |
| @Test |
| public void appendEmptyGroup_noOp() { |
| GroupedList<String> groupedList = createGroupedList(); |
| groupedList.appendGroup(ImmutableList.of()); |
| assertThat(groupedList.isEmpty()).isTrue(); |
| groupedList.appendSingleton("a"); |
| groupedList.appendGroup(ImmutableList.of()); |
| groupedList.appendSingleton("b"); |
| checkGroups(groupedList, ImmutableList.of(ImmutableList.of("a"), ImmutableList.of("b"))); |
| } |
| |
| @Test |
| public void identical_equal() { |
| GroupedList<String> abc1 = createGroupedList(); |
| GroupedList<String> abc2 = createGroupedList(); |
| abc1.appendGroup(ImmutableList.of("a", "b", "c")); |
| abc2.appendGroup(ImmutableList.of("a", "b", "c")); |
| assertThat(abc1).isEqualTo(abc2); |
| } |
| |
| @Test |
| public void appendSingletonAndAppendGroupSizeOne_equal() { |
| GroupedList<String> aSingleton = createGroupedList(); |
| GroupedList<String> aGroup = createGroupedList(); |
| aSingleton.appendSingleton("a"); |
| aGroup.appendGroup(ImmutableList.of("a")); |
| assertThat(aSingleton).isEqualTo(aGroup); |
| } |
| |
| @Test |
| public void differentOrderWithinGroup_equal() { |
| GroupedList<String> ab = createGroupedList(); |
| GroupedList<String> ba = createGroupedList(); |
| ab.appendGroup(ImmutableList.of("a", "b")); |
| ba.appendGroup(ImmutableList.of("b", "a")); |
| assertThat(ab).isEqualTo(ba); |
| } |
| |
| @Test |
| public void differentElements_notEqual() { |
| GroupedList<String> abc = createGroupedList(); |
| GroupedList<String> xyz = createGroupedList(); |
| abc.appendGroup(ImmutableList.of("a", "b", "c")); |
| xyz.appendGroup(ImmutableList.of("x", "y", "z")); |
| assertThat(abc).isNotEqualTo(xyz); |
| } |
| |
| @Test |
| public void differentOrderOfGroups_notEqual() { |
| GroupedList<String> ab = createGroupedList(); |
| GroupedList<String> ba = createGroupedList(); |
| ab.appendSingleton("a"); |
| ab.appendSingleton("b"); |
| ba.appendSingleton("b"); |
| ba.appendSingleton("a"); |
| assertThat(ab).isNotEqualTo(ba); |
| } |
| |
| @Test |
| public void differentGroupings_notEqual() { |
| GroupedList<String> abGroup = createGroupedList(); |
| GroupedList<String> abSingletons = createGroupedList(); |
| abGroup.appendGroup(ImmutableList.of("a", "b")); |
| abSingletons.appendSingleton("a"); |
| abSingletons.appendSingleton("b"); |
| assertThat(abGroup).isNotEqualTo(abSingletons); |
| } |
| |
| @Test |
| public void groups() { |
| GroupedList<String> groupedList = createGroupedList(); |
| ImmutableList<ImmutableList<String>> groups = |
| ImmutableList.of( |
| ImmutableList.of("1"), |
| ImmutableList.of("2a", "2b"), |
| ImmutableList.of("3"), |
| ImmutableList.of("4"), |
| ImmutableList.of("5a", "5b", "5c"), |
| ImmutableList.of("6a", "6b", "6c")); |
| groups.forEach(groupedList::appendGroup); |
| checkGroups(groupedList, groups); |
| } |
| |
| @Test |
| public void remove_groupsIntact() { |
| GroupedList<String> groupedList = createGroupedList(); |
| groupedList.appendGroup(ImmutableList.of("1a", "1b")); |
| groupedList.appendGroup(ImmutableList.of("2a", "2b", "2c")); |
| groupedList.appendGroup(ImmutableList.of("3a", "3b")); |
| |
| groupedList.remove(ImmutableSet.of("2c")); |
| |
| checkGroups( |
| groupedList, |
| ImmutableList.of( |
| ImmutableList.of("1a", "1b"), |
| ImmutableList.of("2a", "2b"), |
| ImmutableList.of("3a", "3b"))); |
| } |
| |
| @Test |
| public void remove_groupBecomesSingleton() { |
| GroupedList<String> groupedList = createGroupedList(); |
| groupedList.appendGroup(ImmutableList.of("1a", "1b")); |
| groupedList.appendGroup(ImmutableList.of("2a", "2b", "2c")); |
| groupedList.appendGroup(ImmutableList.of("3a", "3b")); |
| |
| groupedList.remove(ImmutableSet.of("2b", "2c")); |
| |
| checkGroups( |
| groupedList, |
| ImmutableList.of( |
| ImmutableList.of("1a", "1b"), ImmutableList.of("2a"), ImmutableList.of("3a", "3b"))); |
| } |
| |
| @Test |
| public void remove_groupBecomesEmpty() { |
| GroupedList<String> groupedList = createGroupedList(); |
| groupedList.appendGroup(ImmutableList.of("1a", "1b")); |
| groupedList.appendGroup(ImmutableList.of("2a", "2b", "2c")); |
| groupedList.appendGroup(ImmutableList.of("3a", "3b")); |
| |
| groupedList.remove(ImmutableSet.of("2a", "2b", "2c")); |
| |
| checkGroups( |
| groupedList, ImmutableList.of(ImmutableList.of("1a", "1b"), ImmutableList.of("3a", "3b"))); |
| } |
| |
| @Test |
| public void remove_singleton() { |
| GroupedList<String> groupedList = createGroupedList(); |
| groupedList.appendGroup(ImmutableList.of("1a", "1b")); |
| groupedList.appendSingleton("2"); |
| groupedList.appendGroup(ImmutableList.of("3a", "3b")); |
| |
| groupedList.remove(ImmutableSet.of("2")); |
| |
| checkGroups( |
| groupedList, ImmutableList.of(ImmutableList.of("1a", "1b"), ImmutableList.of("3a", "3b"))); |
| } |
| |
| @Test |
| public void remove_wholeGroupedListBecomesEmpty() { |
| GroupedList<String> groupedList = createGroupedList(); |
| groupedList.appendGroup(ImmutableList.of("1a", "1b")); |
| groupedList.appendGroup(ImmutableList.of("2a", "2b", "2c")); |
| groupedList.appendGroup(ImmutableList.of("3a", "3b")); |
| |
| groupedList.remove(ImmutableSet.of("1a", "1b", "2a", "2b", "2c", "3a", "3b")); |
| |
| checkGroups(groupedList, ImmutableList.of()); |
| } |
| |
| @Test |
| public void remove_elementNotPresent_throws() { |
| GroupedList<String> groupedList = createGroupedList(); |
| groupedList.appendGroup(ImmutableList.of("1a", "1b")); |
| groupedList.appendGroup(ImmutableList.of("2a", "2b", "2c")); |
| groupedList.appendGroup(ImmutableList.of("3a", "3b")); |
| |
| assertThrows(RuntimeException.class, () -> groupedList.remove(ImmutableSet.of("2c", "2d"))); |
| } |
| |
| private static void checkGroups( |
| GroupedList<String> groupedList, List<ImmutableList<String>> expectedGroups) { |
| assertThat(groupedList.isEmpty()).isEqualTo(expectedGroups.isEmpty()); |
| assertThat(groupedList.listSize()).isEqualTo(expectedGroups.size()); |
| assertThat(groupedList).containsExactlyElementsIn(expectedGroups).inOrder(); |
| |
| ImmutableList<String> expectedFlattened = |
| ImmutableList.copyOf(Iterables.concat(expectedGroups)); |
| assertThat(groupedList.numElements()).isEqualTo(expectedFlattened.size()); |
| assertThat(groupedList.getAllElementsAsIterable()) |
| .containsExactlyElementsIn(expectedFlattened) |
| .inOrder(); |
| if (groupedList instanceof GroupedList.WithHashSet) { |
| assertThat(groupedList.toSet()).containsExactlyElementsIn(expectedFlattened); |
| } else { |
| assertThat(groupedList.toSet()).containsExactlyElementsIn(expectedFlattened).inOrder(); |
| } |
| |
| checkCompression(groupedList); |
| } |
| |
| private static void checkCompression(GroupedList<String> groupedList) { |
| @GroupedList.Compressed Object compressed = groupedList.compress(); |
| assertThat(GroupedList.numElements(compressed)).isEqualTo(groupedList.numElements()); |
| assertThat(GroupedList.numGroups(compressed)).isEqualTo(groupedList.listSize()); |
| assertThat(GroupedList.compressedToIterable(compressed)) |
| .containsExactlyElementsIn(groupedList.getAllElementsAsIterable()) |
| .inOrder(); |
| assertThat(GroupedList.create(compressed)).containsExactlyElementsIn(groupedList).inOrder(); |
| assertThat(GroupedList.create(compressed)).isNotInstanceOf(GroupedList.WithHashSet.class); |
| } |
| } |