generator/src/test/java/com/google/archivepatcher/generator/TotalRecompressionLimiterTest.java - platform/external/archive-patcher - Git at Google

 // Copyright 2016 Google Inc. 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.archivepatcher.generator;

 import java.io.File;
 import java.io.UnsupportedEncodingException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;

 /** Tests for {@link TotalRecompressionLimiter}. */
 @RunWith(JUnit4.class)
 @SuppressWarnings("javadoc")
 public class TotalRecompressionLimiterTest {

   private static final File OLD_FILE = null;
   private static final File NEW_FILE = null;

   private static final MinimalZipEntry UNIMPORTANT = makeFakeEntry("/unimportant", 1337);
   private static final MinimalZipEntry ENTRY_A_100K = makeFakeEntry("/a/100k", 100 * 1024);
   private static final MinimalZipEntry ENTRY_B_200K = makeFakeEntry("/b/200k", 200 * 1024);
   private static final MinimalZipEntry ENTRY_C_300K = makeFakeEntry("/c/300k", 300 * 1024);
   private static final MinimalZipEntry ENTRY_D_400K = makeFakeEntry("/d/400k", 400 * 1024);
   private static final MinimalZipEntry IGNORED_A = makeFakeEntry("/ignored/a", 1234);
   private static final MinimalZipEntry IGNORED_B = makeFakeEntry("/ignored/b", 5678);
   private static final MinimalZipEntry IGNORED_C = makeFakeEntry("/ignored/c", 9101112);
   private static final MinimalZipEntry IGNORED_D = makeFakeEntry("/ignored/d", 13141516);

   // First four recommendations are all ones where recompression is required. Note that there is a
   // mix of UNCOMPRESS_NEW and UNCOMPRESS_BOTH, both of which will have the "new" entry flagged for
   // recompression (i.e., should be relevant to the filtering logic).
   private static final QualifiedRecommendation REC_A_100K =
       new QualifiedRecommendation(
           UNIMPORTANT,
           ENTRY_A_100K,
           Recommendation.UNCOMPRESS_BOTH,
           RecommendationReason.COMPRESSED_BYTES_CHANGED);
   private static final QualifiedRecommendation REC_B_200K =
       new QualifiedRecommendation(
           UNIMPORTANT,
           ENTRY_B_200K,
           Recommendation.UNCOMPRESS_NEW,
           RecommendationReason.UNCOMPRESSED_CHANGED_TO_COMPRESSED);
   private static final QualifiedRecommendation REC_C_300K =
       new QualifiedRecommendation(
           UNIMPORTANT,
           ENTRY_C_300K,
           Recommendation.UNCOMPRESS_BOTH,
           RecommendationReason.COMPRESSED_BYTES_CHANGED);
   private static final QualifiedRecommendation REC_D_400K =
       new QualifiedRecommendation(
           UNIMPORTANT,
           ENTRY_D_400K,
           Recommendation.UNCOMPRESS_BOTH,
           RecommendationReason.COMPRESSED_BYTES_CHANGED);

   // Remaining recommendations are all ones where recompression is NOT required. Note the mixture of
   // UNCOMPRESS_NEITHER and UNCOMPRESS_OLD, neither of which will have the "new" entry flagged for
   // recompression (ie., must be ignored by the filtering logic).
   private static final QualifiedRecommendation REC_IGNORED_A_UNCHANGED =
       new QualifiedRecommendation(
           UNIMPORTANT,
           IGNORED_A,
           Recommendation.UNCOMPRESS_NEITHER,
           RecommendationReason.COMPRESSED_BYTES_IDENTICAL);
   private static final QualifiedRecommendation REC_IGNORED_B_BOTH_UNCOMPRESSED =
       new QualifiedRecommendation(
           UNIMPORTANT,
           IGNORED_B,
           Recommendation.UNCOMPRESS_NEITHER,
           RecommendationReason.BOTH_ENTRIES_UNCOMPRESSED);
   private static final QualifiedRecommendation REC_IGNORED_C_UNSUITABLE =
       new QualifiedRecommendation(
           UNIMPORTANT,
           IGNORED_C,
           Recommendation.UNCOMPRESS_NEITHER,
           RecommendationReason.UNSUITABLE);
   private static final QualifiedRecommendation REC_IGNORED_D_CHANGED_TO_UNCOMPRESSED =
       new QualifiedRecommendation(
           UNIMPORTANT,
           IGNORED_D,
           Recommendation.UNCOMPRESS_OLD,
           RecommendationReason.COMPRESSED_CHANGED_TO_UNCOMPRESSED);

   /** Convenience reference to all the recommendations that should be ignored by filtering. */
   private static final List<QualifiedRecommendation> ALL_IGNORED_RECS =
       Collections.unmodifiableList(
           Arrays.asList(
               REC_IGNORED_A_UNCHANGED,
               REC_IGNORED_B_BOTH_UNCOMPRESSED,
               REC_IGNORED_C_UNSUITABLE,
               REC_IGNORED_D_CHANGED_TO_UNCOMPRESSED));

   /** Convenience reference to all the recommendations that are subject to filtering. */
   private static final List<QualifiedRecommendation> ALL_RECS =
       Collections.unmodifiableList(
           Arrays.asList(
               REC_IGNORED_A_UNCHANGED,
               REC_A_100K,
               REC_IGNORED_B_BOTH_UNCOMPRESSED,
               REC_D_400K,
               REC_IGNORED_C_UNSUITABLE,
               REC_B_200K,
               REC_IGNORED_D_CHANGED_TO_UNCOMPRESSED,
               REC_C_300K));

   /**
    * Given {@link QualifiedRecommendation}s, manufacture equivalents altered in the way that the
    * {@link TotalRecompressionLimiter} would.
    *
    * @param originals the original recommendations
    * @return the altered recommendations
    */
   private static final List<QualifiedRecommendation> suppressed(
       QualifiedRecommendation... originals) {
     List<QualifiedRecommendation> result = new ArrayList<>(originals.length);
     for (QualifiedRecommendation original : originals) {
       result.add(
           new QualifiedRecommendation(
               original.getOldEntry(),
               original.getNewEntry(),
               Recommendation.UNCOMPRESS_NEITHER,
               RecommendationReason.RESOURCE_CONSTRAINED));
     }
     return result;
   }

   /**
    * Make a structurally valid but totally bogus {@link MinimalZipEntry} for the purpose of testing
    * the {@link RecommendationModifier}.
    *
    * @param path the path to set on the entry, to help with debugging
    * @param uncompressedSize the uncompressed size of the entry, in bytes
    * @return the entry
    */
   private static MinimalZipEntry makeFakeEntry(String path, long uncompressedSize) {
     try {
       return new MinimalZipEntry(
           8, // == deflate
           0, // crc32OfUncompressedData (ignored for this test)
           0, // compressedSize (ignored for this test)
           uncompressedSize,
           path.getBytes("UTF8"),
           true, // generalPurposeFlagBit11 (true=UTF8)
           0 // fileOffsetOfLocalEntry (ignored for this test)
           );
     } catch (UnsupportedEncodingException e) {
       throw new RuntimeException(e); // Impossible on any modern system
     }
   }

   @Test
   public void testNegativeLimit() {
     try {
       new TotalRecompressionLimiter(-1);
       Assert.fail("Set a negative limit");
     } catch (IllegalArgumentException expected) {
       // Pass
     }
   }

   /**
    * Asserts that the two collections contain exactly the same elements. This isn't as rigorous as
    * it should be, but is ok for this test scenario. Checks the contents but not the iteration order
    * of the collections handed in.
    *
    * @param c1 the first collection
    * @param c2 the second collection
    */
   private static <T> void assertEquivalence(Collection<T> c1, Collection<T> c2) {
     Assert.assertEquals(c1.size(), c2.size());
     Assert.assertTrue(c1.containsAll(c2));
     Assert.assertTrue(c2.containsAll(c1));
   }

   @Test
   public void testZeroLimit() {
     TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(0);
     List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
     expected.addAll(suppressed(REC_A_100K, REC_B_200K, REC_C_300K, REC_D_400K));
     expected.addAll(ALL_IGNORED_RECS);
     assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
   }

   @Test
   public void testMaxLimit() {
     TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(Long.MAX_VALUE);
     assertEquivalence(ALL_RECS, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
   }

   @Test
   public void testLimit_ExactlySmallest() {
     long limit = REC_A_100K.getNewEntry().getUncompressedSize(); // Exactly large enough
     TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
     List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
     expected.add(REC_A_100K);
     expected.addAll(suppressed(REC_B_200K, REC_C_300K, REC_D_400K));
     expected.addAll(ALL_IGNORED_RECS);
     assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
   }

   @Test
   public void testLimit_EdgeUnderSmallest() {
     long limit = REC_A_100K.getNewEntry().getUncompressedSize() - 1; // 1 byte too small
     TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
     List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
     expected.addAll(suppressed(REC_A_100K, REC_B_200K, REC_C_300K, REC_D_400K));
     expected.addAll(ALL_IGNORED_RECS);
     assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
   }

   @Test
   public void testLimit_EdgeOverSmallest() {
     long limit = REC_A_100K.getNewEntry().getUncompressedSize() + 1; // 1 byte extra room
     TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
     List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
     expected.add(REC_A_100K);
     expected.addAll(suppressed(REC_B_200K, REC_C_300K, REC_D_400K));
     expected.addAll(ALL_IGNORED_RECS);
     assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
   }

   @Test
   public void testLimit_ExactlyLargest() {
     long limit = REC_D_400K.getNewEntry().getUncompressedSize(); // Exactly large enough
     TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
     List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
     expected.add(REC_D_400K);
     expected.addAll(suppressed(REC_A_100K, REC_B_200K, REC_C_300K));
     expected.addAll(ALL_IGNORED_RECS);
     assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
   }

   @Test
   public void testLimit_EdgeUnderLargest() {
     long limit = REC_D_400K.getNewEntry().getUncompressedSize() - 1; // 1 byte too small
     TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
     List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
     expected.add(REC_C_300K);
     expected.addAll(suppressed(REC_A_100K, REC_B_200K, REC_D_400K));
     expected.addAll(ALL_IGNORED_RECS);
     assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
   }

   @Test
   public void testLimit_EdgeOverLargest() {
     long limit = REC_D_400K.getNewEntry().getUncompressedSize() + 1; // 1 byte extra room
     TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
     List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
     expected.add(REC_D_400K);
     expected.addAll(suppressed(REC_A_100K, REC_B_200K, REC_C_300K));
     expected.addAll(ALL_IGNORED_RECS);
     assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
   }

   @Test
   public void testLimit_Complex() {
     // A more nuanced test. Here we set up a limit of 600k - big enough to get the largest and the
     // THIRD largest files. The second largest will fail because there isn't enough space after
     // adding the first largest, and the fourth largest will fail because there is not enough space
     // after adding the third largest. Tricky.
     long limit =
         REC_D_400K.getNewEntry().getUncompressedSize()
             + REC_B_200K.getNewEntry().getUncompressedSize();
     TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
     List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
     expected.add(REC_B_200K);
     expected.add(REC_D_400K);
     expected.addAll(suppressed(REC_A_100K, REC_C_300K));
     expected.addAll(ALL_IGNORED_RECS);
     assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
   }
 }
	// Copyright 2016 Google Inc. 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.archivepatcher.generator;

	import java.io.File;
	import java.io.UnsupportedEncodingException;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.List;
	import org.junit.Assert;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.JUnit4;

	/** Tests for {@link TotalRecompressionLimiter}. */
	@RunWith(JUnit4.class)
	@SuppressWarnings("javadoc")
	public class TotalRecompressionLimiterTest {

	private static final File OLD_FILE = null;
	private static final File NEW_FILE = null;

	private static final MinimalZipEntry UNIMPORTANT = makeFakeEntry("/unimportant", 1337);
	private static final MinimalZipEntry ENTRY_A_100K = makeFakeEntry("/a/100k", 100 * 1024);
	private static final MinimalZipEntry ENTRY_B_200K = makeFakeEntry("/b/200k", 200 * 1024);
	private static final MinimalZipEntry ENTRY_C_300K = makeFakeEntry("/c/300k", 300 * 1024);
	private static final MinimalZipEntry ENTRY_D_400K = makeFakeEntry("/d/400k", 400 * 1024);
	private static final MinimalZipEntry IGNORED_A = makeFakeEntry("/ignored/a", 1234);
	private static final MinimalZipEntry IGNORED_B = makeFakeEntry("/ignored/b", 5678);
	private static final MinimalZipEntry IGNORED_C = makeFakeEntry("/ignored/c", 9101112);
	private static final MinimalZipEntry IGNORED_D = makeFakeEntry("/ignored/d", 13141516);

	// First four recommendations are all ones where recompression is required. Note that there is a
	// mix of UNCOMPRESS_NEW and UNCOMPRESS_BOTH, both of which will have the "new" entry flagged for
	// recompression (i.e., should be relevant to the filtering logic).
	private static final QualifiedRecommendation REC_A_100K =
	new QualifiedRecommendation(
	UNIMPORTANT,
	ENTRY_A_100K,
	Recommendation.UNCOMPRESS_BOTH,
	RecommendationReason.COMPRESSED_BYTES_CHANGED);
	private static final QualifiedRecommendation REC_B_200K =
	new QualifiedRecommendation(
	UNIMPORTANT,
	ENTRY_B_200K,
	Recommendation.UNCOMPRESS_NEW,
	RecommendationReason.UNCOMPRESSED_CHANGED_TO_COMPRESSED);
	private static final QualifiedRecommendation REC_C_300K =
	new QualifiedRecommendation(
	UNIMPORTANT,
	ENTRY_C_300K,
	Recommendation.UNCOMPRESS_BOTH,
	RecommendationReason.COMPRESSED_BYTES_CHANGED);
	private static final QualifiedRecommendation REC_D_400K =
	new QualifiedRecommendation(
	UNIMPORTANT,
	ENTRY_D_400K,
	Recommendation.UNCOMPRESS_BOTH,
	RecommendationReason.COMPRESSED_BYTES_CHANGED);

	// Remaining recommendations are all ones where recompression is NOT required. Note the mixture of
	// UNCOMPRESS_NEITHER and UNCOMPRESS_OLD, neither of which will have the "new" entry flagged for
	// recompression (ie., must be ignored by the filtering logic).
	private static final QualifiedRecommendation REC_IGNORED_A_UNCHANGED =
	new QualifiedRecommendation(
	UNIMPORTANT,
	IGNORED_A,
	Recommendation.UNCOMPRESS_NEITHER,
	RecommendationReason.COMPRESSED_BYTES_IDENTICAL);
	private static final QualifiedRecommendation REC_IGNORED_B_BOTH_UNCOMPRESSED =
	new QualifiedRecommendation(
	UNIMPORTANT,
	IGNORED_B,
	Recommendation.UNCOMPRESS_NEITHER,
	RecommendationReason.BOTH_ENTRIES_UNCOMPRESSED);
	private static final QualifiedRecommendation REC_IGNORED_C_UNSUITABLE =
	new QualifiedRecommendation(
	UNIMPORTANT,
	IGNORED_C,
	Recommendation.UNCOMPRESS_NEITHER,
	RecommendationReason.UNSUITABLE);
	private static final QualifiedRecommendation REC_IGNORED_D_CHANGED_TO_UNCOMPRESSED =
	new QualifiedRecommendation(
	UNIMPORTANT,
	IGNORED_D,
	Recommendation.UNCOMPRESS_OLD,
	RecommendationReason.COMPRESSED_CHANGED_TO_UNCOMPRESSED);

	/** Convenience reference to all the recommendations that should be ignored by filtering. */
	private static final List<QualifiedRecommendation> ALL_IGNORED_RECS =
	Collections.unmodifiableList(
	Arrays.asList(
	REC_IGNORED_A_UNCHANGED,
	REC_IGNORED_B_BOTH_UNCOMPRESSED,
	REC_IGNORED_C_UNSUITABLE,
	REC_IGNORED_D_CHANGED_TO_UNCOMPRESSED));

	/** Convenience reference to all the recommendations that are subject to filtering. */
	private static final List<QualifiedRecommendation> ALL_RECS =
	Collections.unmodifiableList(
	Arrays.asList(
	REC_IGNORED_A_UNCHANGED,
	REC_A_100K,
	REC_IGNORED_B_BOTH_UNCOMPRESSED,
	REC_D_400K,
	REC_IGNORED_C_UNSUITABLE,
	REC_B_200K,
	REC_IGNORED_D_CHANGED_TO_UNCOMPRESSED,
	REC_C_300K));

	/**
	* Given {@link QualifiedRecommendation}s, manufacture equivalents altered in the way that the
	* {@link TotalRecompressionLimiter} would.
	*
	* @param originals the original recommendations
	* @return the altered recommendations
	*/
	private static final List<QualifiedRecommendation> suppressed(
	QualifiedRecommendation... originals) {
	List<QualifiedRecommendation> result = new ArrayList<>(originals.length);
	for (QualifiedRecommendation original : originals) {
	result.add(
	new QualifiedRecommendation(
	original.getOldEntry(),
	original.getNewEntry(),
	Recommendation.UNCOMPRESS_NEITHER,
	RecommendationReason.RESOURCE_CONSTRAINED));
	}
	return result;
	}

	/**
	* Make a structurally valid but totally bogus {@link MinimalZipEntry} for the purpose of testing
	* the {@link RecommendationModifier}.
	*
	* @param path the path to set on the entry, to help with debugging
	* @param uncompressedSize the uncompressed size of the entry, in bytes
	* @return the entry
	*/
	private static MinimalZipEntry makeFakeEntry(String path, long uncompressedSize) {
	try {
	return new MinimalZipEntry(
	8, // == deflate
	0, // crc32OfUncompressedData (ignored for this test)
	0, // compressedSize (ignored for this test)
	uncompressedSize,
	path.getBytes("UTF8"),
	true, // generalPurposeFlagBit11 (true=UTF8)
	0 // fileOffsetOfLocalEntry (ignored for this test)
	);
	} catch (UnsupportedEncodingException e) {
	throw new RuntimeException(e); // Impossible on any modern system
	}
	}

	@Test
	public void testNegativeLimit() {
	try {
	new TotalRecompressionLimiter(-1);
	Assert.fail("Set a negative limit");
	} catch (IllegalArgumentException expected) {
	// Pass
	}
	}

	/**
	* Asserts that the two collections contain exactly the same elements. This isn't as rigorous as
	* it should be, but is ok for this test scenario. Checks the contents but not the iteration order
	* of the collections handed in.
	*
	* @param c1 the first collection
	* @param c2 the second collection
	*/
	private static <T> void assertEquivalence(Collection<T> c1, Collection<T> c2) {
	Assert.assertEquals(c1.size(), c2.size());
	Assert.assertTrue(c1.containsAll(c2));
	Assert.assertTrue(c2.containsAll(c1));
	}

	@Test
	public void testZeroLimit() {
	TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(0);
	List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
	expected.addAll(suppressed(REC_A_100K, REC_B_200K, REC_C_300K, REC_D_400K));
	expected.addAll(ALL_IGNORED_RECS);
	assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
	}

	@Test
	public void testMaxLimit() {
	TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(Long.MAX_VALUE);
	assertEquivalence(ALL_RECS, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
	}

	@Test
	public void testLimit_ExactlySmallest() {
	long limit = REC_A_100K.getNewEntry().getUncompressedSize(); // Exactly large enough
	TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
	List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
	expected.add(REC_A_100K);
	expected.addAll(suppressed(REC_B_200K, REC_C_300K, REC_D_400K));
	expected.addAll(ALL_IGNORED_RECS);
	assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
	}

	@Test
	public void testLimit_EdgeUnderSmallest() {
	long limit = REC_A_100K.getNewEntry().getUncompressedSize() - 1; // 1 byte too small
	TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
	List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
	expected.addAll(suppressed(REC_A_100K, REC_B_200K, REC_C_300K, REC_D_400K));
	expected.addAll(ALL_IGNORED_RECS);
	assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
	}

	@Test
	public void testLimit_EdgeOverSmallest() {
	long limit = REC_A_100K.getNewEntry().getUncompressedSize() + 1; // 1 byte extra room
	TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
	List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
	expected.add(REC_A_100K);
	expected.addAll(suppressed(REC_B_200K, REC_C_300K, REC_D_400K));
	expected.addAll(ALL_IGNORED_RECS);
	assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
	}

	@Test
	public void testLimit_ExactlyLargest() {
	long limit = REC_D_400K.getNewEntry().getUncompressedSize(); // Exactly large enough
	TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
	List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
	expected.add(REC_D_400K);
	expected.addAll(suppressed(REC_A_100K, REC_B_200K, REC_C_300K));
	expected.addAll(ALL_IGNORED_RECS);
	assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
	}

	@Test
	public void testLimit_EdgeUnderLargest() {
	long limit = REC_D_400K.getNewEntry().getUncompressedSize() - 1; // 1 byte too small
	TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
	List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
	expected.add(REC_C_300K);
	expected.addAll(suppressed(REC_A_100K, REC_B_200K, REC_D_400K));
	expected.addAll(ALL_IGNORED_RECS);
	assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
	}

	@Test
	public void testLimit_EdgeOverLargest() {
	long limit = REC_D_400K.getNewEntry().getUncompressedSize() + 1; // 1 byte extra room
	TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
	List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
	expected.add(REC_D_400K);
	expected.addAll(suppressed(REC_A_100K, REC_B_200K, REC_C_300K));
	expected.addAll(ALL_IGNORED_RECS);
	assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
	}

	@Test
	public void testLimit_Complex() {
	// A more nuanced test. Here we set up a limit of 600k - big enough to get the largest and the
	// THIRD largest files. The second largest will fail because there isn't enough space after
	// adding the first largest, and the fourth largest will fail because there is not enough space
	// after adding the third largest. Tricky.
	long limit =
	REC_D_400K.getNewEntry().getUncompressedSize()
	+ REC_B_200K.getNewEntry().getUncompressedSize();
	TotalRecompressionLimiter limiter = new TotalRecompressionLimiter(limit);
	List<QualifiedRecommendation> expected = new ArrayList<QualifiedRecommendation>();
	expected.add(REC_B_200K);
	expected.add(REC_D_400K);
	expected.addAll(suppressed(REC_A_100K, REC_C_300K));
	expected.addAll(ALL_IGNORED_RECS);
	assertEquivalence(expected, limiter.getModifiedRecommendations(OLD_FILE, NEW_FILE, ALL_RECS));
	}
	}