tzdata/update2/src/test/libcore/tzdata/update2/TimeZoneDistroInstallerTest.java - platform/libcore - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * 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 libcore.tzdata.update2;

 import junit.framework.AssertionFailedError;
 import junit.framework.TestCase;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Arrays;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 import java.util.zip.ZipOutputStream;
 import libcore.io.IoUtils;
 import libcore.io.Streams;
 import libcore.tzdata.shared2.DistroVersion;
 import libcore.tzdata.shared2.FileUtils;
 import libcore.tzdata.shared2.TimeZoneDistro;
 import libcore.tzdata.testing.ZoneInfoTestHelper;
 import libcore.tzdata.update2.tools.TimeZoneDistroBuilder;

 /**
  * Tests for {@link TimeZoneDistroInstaller}.
  */
 public class TimeZoneDistroInstallerTest extends TestCase {

     // OLDER_RULES_VERSION < SYSTEM_RULES_VERSION < NEW_RULES_VERSION < NEWER_RULES_VERSION
     private static final String OLDER_RULES_VERSION = "2030a";
     private static final String SYSTEM_RULES_VERSION = "2030b";
     private static final String NEW_RULES_VERSION = "2030c";
     private static final String NEWER_RULES_VERSION = "2030d";

     private TimeZoneDistroInstaller installer;
     private File tempDir;
     private File testInstallDir;
     private File testSystemTzDataDir;

     @Override
     public void setUp() throws Exception {
         super.setUp();
         tempDir = createDirectory("tempDir");
         testInstallDir =  createDirectory("testInstall");
         testSystemTzDataDir =  createDirectory("testSystemTzData");

         // Create a file to represent the tzdata file in the /system partition of the device.
         File testSystemTzDataFile = new File(testSystemTzDataDir, "tzdata");
         byte[] systemTzDataBytes = createTzData(SYSTEM_RULES_VERSION);
         createFile(testSystemTzDataFile, systemTzDataBytes);

         installer = new TimeZoneDistroInstaller(
                 "TimeZoneDistroInstallerTest", testSystemTzDataFile, testInstallDir);
     }

     private static File createDirectory(String prefix) throws Exception {
         File dir = File.createTempFile(prefix, "");
         assertTrue(dir.delete());
         assertTrue(dir.mkdir());
         return dir;
     }

     @Override
     public void tearDown() throws Exception {
         if (testSystemTzDataDir.exists()) {
             FileUtils.deleteRecursive(testInstallDir);
         }
         if (testInstallDir.exists()) {
             FileUtils.deleteRecursive(testInstallDir);
         }
         if (tempDir.exists()) {
             FileUtils.deleteRecursive(tempDir);
         }
         super.tearDown();
     }

     /** Tests the an update on a device will fail if the /system tzdata file cannot be found. */
     public void testInstall_badSystemFile() throws Exception {
         File doesNotExist = new File(testSystemTzDataDir, "doesNotExist");
         TimeZoneDistroInstaller brokenSystemInstaller = new TimeZoneDistroInstaller(
                 "TimeZoneDistroInstallerTest", doesNotExist, testInstallDir);
         TimeZoneDistro tzData = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);

         try {
             brokenSystemInstaller.installWithErrorCode(tzData.getBytes());
             fail();
         } catch (IOException expected) {}

         assertNoContentInstalled();
     }

     /** Tests the first successful update on a device */
     public void testInstall_successfulFirstUpdate() throws Exception {
         TimeZoneDistro distro = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);

         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_SUCCESS,
                 installer.installWithErrorCode(distro.getBytes()));
         assertDistroInstalled(distro);
     }

     /**
      * Tests we can install an update the same version as is in /system.
      */
     public void testInstall_successfulFirstUpdate_sameVersionAsSystem() throws Exception {
         TimeZoneDistro distro = createValidTimeZoneDistro(SYSTEM_RULES_VERSION, 1);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_SUCCESS,
                 installer.installWithErrorCode(distro.getBytes()));
         assertDistroInstalled(distro);
     }

     /**
      * Tests we cannot install an update older than the version in /system.
      */
     public void testInstall_unsuccessfulFirstUpdate_olderVersionThanSystem() throws Exception {
         TimeZoneDistro distro = createValidTimeZoneDistro(OLDER_RULES_VERSION, 1);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_FAIL_RULES_TOO_OLD,
                 installer.installWithErrorCode(distro.getBytes()));
         assertNoContentInstalled();
     }

     /**
      * Tests an update on a device when there is a prior update already applied.
      */
     public void testInstall_successfulFollowOnUpdate_newerVersion() throws Exception {
         TimeZoneDistro distro1 = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_SUCCESS,
                 installer.installWithErrorCode(distro1.getBytes()));
         assertDistroInstalled(distro1);

         TimeZoneDistro distro2 = createValidTimeZoneDistro(NEW_RULES_VERSION, 2);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_SUCCESS,
                 installer.installWithErrorCode(distro2.getBytes()));
         assertDistroInstalled(distro2);

         TimeZoneDistro distro3 = createValidTimeZoneDistro(NEWER_RULES_VERSION, 1);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_SUCCESS,
                 installer.installWithErrorCode(distro3.getBytes()));
         assertDistroInstalled(distro3);
     }

     /**
      * Tests an update on a device when there is a prior update already applied, but the follow
      * on update is older than in /system.
      */
     public void testInstall_unsuccessfulFollowOnUpdate_olderVersion() throws Exception {
         TimeZoneDistro distro1 = createValidTimeZoneDistro(NEW_RULES_VERSION, 2);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_SUCCESS,
                 installer.installWithErrorCode(distro1.getBytes()));
         assertDistroInstalled(distro1);

         TimeZoneDistro distro2 = createValidTimeZoneDistro(OLDER_RULES_VERSION, 1);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_FAIL_RULES_TOO_OLD,
                 installer.installWithErrorCode(distro2.getBytes()));
         assertDistroInstalled(distro1);
     }

     /** Tests that a distro with a missing file will not update the content. */
     public void testInstall_missingTzDataFile() throws Exception {
         TimeZoneDistro installedDistro = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_SUCCESS,
                 installer.installWithErrorCode(installedDistro.getBytes()));
         assertDistroInstalled(installedDistro);

         TimeZoneDistro incompleteDistro =
                 createValidTimeZoneDistroBuilder(NEWER_RULES_VERSION, 1)
                         .clearTzDataForTests()
                         .buildUnvalidated();
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_STRUCTURE,
                 installer.installWithErrorCode(incompleteDistro.getBytes()));
         assertDistroInstalled(installedDistro);
     }

     /** Tests that a distro with a missing file will not update the content. */
     public void testInstall_missingIcuFile() throws Exception {
         TimeZoneDistro installedDistro = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_SUCCESS,
                 installer.installWithErrorCode(installedDistro.getBytes()));
         assertDistroInstalled(installedDistro);

         TimeZoneDistro incompleteDistro =
                 createValidTimeZoneDistroBuilder(NEWER_RULES_VERSION, 1)
                         .clearIcuDataForTests()
                         .buildUnvalidated();
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_STRUCTURE,
                 installer.installWithErrorCode(incompleteDistro.getBytes()));
         assertDistroInstalled(installedDistro);
     }

     /**
      * Tests that an update will be unpacked even if there is a partial update from a previous run.
      */
     public void testInstall_withWorkingDir() throws Exception {
         File workingDir = installer.getWorkingDir();
         assertTrue(workingDir.mkdir());
         createFile(new File(workingDir, "myFile"), new byte[] { 'a' });

         TimeZoneDistro distro = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_SUCCESS,
                 installer.installWithErrorCode(distro.getBytes()));
         assertDistroInstalled(distro);
     }

     /**
      * Tests that a distro without a distro version file will be rejected.
      */
     public void testInstall_withMissingDistroVersionFile() throws Exception {
         // Create a distro without a version file.
         TimeZoneDistro distro = createValidTimeZoneDistroBuilder(NEW_RULES_VERSION, 1)
                 .clearVersionForTests()
                 .buildUnvalidated();
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_STRUCTURE,
                 installer.installWithErrorCode(distro.getBytes()));
         assertNoContentInstalled();
     }

     /**
      * Tests that a distro with an newer distro version will be rejected.
      */
     public void testInstall_withNewerDistroVersion() throws Exception {
         // Create a distro that will appear to be newer than the one currently supported.
         TimeZoneDistro distro = createValidTimeZoneDistroBuilder(NEW_RULES_VERSION, 1)
                 .replaceFormatVersionForTests(2, 1)
                 .buildUnvalidated();
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_FORMAT_VERSION,
                 installer.installWithErrorCode(distro.getBytes()));
         assertNoContentInstalled();
     }

     /**
      * Tests that a distro with a badly formed distro version will be rejected.
      */
     public void testInstall_withBadlyFormedDistroVersion() throws Exception {
         // Create a distro that has an invalid major distro version. It should be 3 numeric
         // characters, "." and 3 more numeric characters.
         DistroVersion validDistroVersion = new DistroVersion(1, 1, NEW_RULES_VERSION, 1);
         byte[] invalidFormatVersionBytes = validDistroVersion.toBytes();
         invalidFormatVersionBytes[0] = 'A';

         TimeZoneDistro distro = createTimeZoneDistroWithVersionBytes(invalidFormatVersionBytes);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_STRUCTURE,
                 installer.installWithErrorCode(distro.getBytes()));
         assertNoContentInstalled();
     }

     /**
      * Tests that a distro with a badly formed revision will be rejected.
      */
     public void testInstall_withBadlyFormedRevision() throws Exception {
         // Create a distro that has an invalid revision. It should be 3 numeric characters.
         DistroVersion validDistroVersion = new DistroVersion(1, 1, NEW_RULES_VERSION, 1);
         byte[] invalidRevisionBytes = validDistroVersion.toBytes();
         invalidRevisionBytes[invalidRevisionBytes.length - 3] = 'A';

         TimeZoneDistro distro = createTimeZoneDistroWithVersionBytes(invalidRevisionBytes);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_STRUCTURE,
                 installer.installWithErrorCode(distro.getBytes()));
         assertNoContentInstalled();
     }

     /**
      * Tests that a distro with a badly formed rules version will be rejected.
      */
     public void testInstall_withBadlyFormedRulesVersion() throws Exception {
         // Create a distro that has an invalid rules version. It should be in the form "2016c".
         DistroVersion validDistroVersion = new DistroVersion(1, 1, NEW_RULES_VERSION, 1);
         byte[] invalidRulesVersionBytes = validDistroVersion.toBytes();
         invalidRulesVersionBytes[invalidRulesVersionBytes.length - 6] = 'B';

         TimeZoneDistro distro = createTimeZoneDistroWithVersionBytes(invalidRulesVersionBytes);
         assertEquals(
                 TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_STRUCTURE,
                 installer.installWithErrorCode(distro.getBytes()));
         assertNoContentInstalled();
     }

     public void testUninstall_noExistingDataDistro() throws Exception {
         assertFalse(installer.uninstall());
         assertNoContentInstalled();
     }

     public void testUninstall_existingDataDistro() throws Exception {
         File currentDataDir = installer.getCurrentTzDataDir();
         assertTrue(currentDataDir.mkdir());

         assertTrue(installer.uninstall());
         assertNoContentInstalled();
     }

     public void testUninstall_oldDirsAlreadyExists() throws Exception {
         File oldTzDataDir = installer.getOldTzDataDir();
         assertTrue(oldTzDataDir.mkdir());

         File currentDataDir = installer.getCurrentTzDataDir();
         assertTrue(currentDataDir.mkdir());

         assertTrue(installer.uninstall());
         assertNoContentInstalled();
     }

     public void testGetSystemRulesVersion() throws Exception {
         assertEquals(SYSTEM_RULES_VERSION, installer.getSystemRulesVersion());
     }

     private static TimeZoneDistro createValidTimeZoneDistro(
             String rulesVersion, int revision) throws Exception {
         return createValidTimeZoneDistroBuilder(rulesVersion, revision).build();
     }

     private static TimeZoneDistroBuilder createValidTimeZoneDistroBuilder(
             String rulesVersion, int revision) throws Exception {

         byte[] bionicTzData = createTzData(rulesVersion);
         byte[] icuData = new byte[] { 'a' };
         DistroVersion distroVersion = new DistroVersion(
                 DistroVersion.CURRENT_FORMAT_MAJOR_VERSION,
                 DistroVersion.CURRENT_FORMAT_MINOR_VERSION,
                 rulesVersion,
                 revision);
         return new TimeZoneDistroBuilder()
                 .setDistroVersion(distroVersion)
                 .setTzData(bionicTzData)
                 .setIcuData(icuData);
     }

     private void assertDistroInstalled(TimeZoneDistro expectedDistro) throws Exception {
         assertTrue(testInstallDir.exists());

         File currentTzDataDir = installer.getCurrentTzDataDir();
         assertTrue(currentTzDataDir.exists());

         File distroVersionFile =
                 new File(currentTzDataDir, TimeZoneDistro.DISTRO_VERSION_FILE_NAME);
         assertTrue(distroVersionFile.exists());

         File bionicFile = new File(currentTzDataDir, TimeZoneDistro.TZDATA_FILE_NAME);
         assertTrue(bionicFile.exists());

         File icuFile = new File(currentTzDataDir, TimeZoneDistro.ICU_DATA_FILE_NAME);
         assertTrue(icuFile.exists());

         // Assert getInstalledDistroVersion() is reporting correctly.
         assertEquals(expectedDistro.getDistroVersion(), installer.getInstalledDistroVersion());

         try (ZipInputStream zis = new ZipInputStream(
                 new ByteArrayInputStream(expectedDistro.getBytes()))) {
             ZipEntry entry;
             while ((entry = zis.getNextEntry()) != null) {
                 String entryName = entry.getName();
                 File actualFile;
                 if (entryName.endsWith(TimeZoneDistro.DISTRO_VERSION_FILE_NAME)) {
                    actualFile = distroVersionFile;
                 } else if (entryName.endsWith(TimeZoneDistro.ICU_DATA_FILE_NAME)) {
                     actualFile = icuFile;
                 } else if (entryName.endsWith(TimeZoneDistro.TZDATA_FILE_NAME)) {
                     actualFile = bionicFile;
                 } else {
                     throw new AssertionFailedError("Unknown file found");
                 }
                 assertContentsMatches(zis, actualFile);
             }
         }

         // Also check no working directory is left lying around.
         File workingDir = installer.getWorkingDir();
         assertFalse(workingDir.exists());
     }

     private void assertContentsMatches(InputStream expected, File actual)
             throws Exception {
         byte[] actualBytes = IoUtils.readFileAsByteArray(actual.getPath());
         byte[] expectedBytes = Streams.readFullyNoClose(expected);
         assertTrue(Arrays.equals(expectedBytes, actualBytes));
     }

     private void assertNoContentInstalled() throws Exception {
         assertNull(installer.getInstalledDistroVersion());

         File currentTzDataDir = installer.getCurrentTzDataDir();
         assertFalse(currentTzDataDir.exists());

         // Also check no working directories are left lying around.
         File workingDir = installer.getWorkingDir();
         assertFalse(workingDir.exists());

         File oldDataDir = installer.getOldTzDataDir();
         assertFalse(oldDataDir.exists());
     }

     private static byte[] createTzData(String rulesVersion) {
         return new ZoneInfoTestHelper.TzDataBuilder()
                 .initializeToValid()
                 .setHeaderMagic("tzdata" + rulesVersion)
                 .build();
     }

     private static void createFile(File file, byte[] bytes) {
         try (FileOutputStream fos = new FileOutputStream(file)) {
             fos.write(bytes);
         } catch (IOException e) {
             fail(e.getMessage());
         }
     }

     /**
      * Creates a TimeZoneDistro containing arbitrary bytes in the version file. Used for testing
      * distros with badly formed version info.
      */
     private static TimeZoneDistro createTimeZoneDistroWithVersionBytes(byte[] versionBytes)
             throws Exception {

         // Create a valid distro, then manipulate the version file.
         TimeZoneDistro distro = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);
         byte[] distroBytes = distro.getBytes();

         ByteArrayOutputStream baos = new ByteArrayOutputStream(distroBytes.length);
         try (ZipInputStream zipInputStream =
                      new ZipInputStream(new ByteArrayInputStream(distroBytes));
              ZipOutputStream zipOutputStream = new ZipOutputStream(baos)) {

             ZipEntry entry;
             while ((entry = zipInputStream.getNextEntry()) != null) {
                 zipOutputStream.putNextEntry(entry);
                 if (entry.getName().equals(TimeZoneDistro.DISTRO_VERSION_FILE_NAME)) {
                     // Replace the content.
                     zipOutputStream.write(versionBytes);
                 }  else {
                     // Just copy the content.
                     Streams.copy(zipInputStream, zipOutputStream);
                 }
                 zipOutputStream.closeEntry();
                 zipInputStream.closeEntry();
             }
         }
         return new TimeZoneDistro(baos.toByteArray());
     }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* 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 libcore.tzdata.update2;

	import junit.framework.AssertionFailedError;
	import junit.framework.TestCase;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.util.Arrays;
	import java.util.zip.ZipEntry;
	import java.util.zip.ZipInputStream;
	import java.util.zip.ZipOutputStream;
	import libcore.io.IoUtils;
	import libcore.io.Streams;
	import libcore.tzdata.shared2.DistroVersion;
	import libcore.tzdata.shared2.FileUtils;
	import libcore.tzdata.shared2.TimeZoneDistro;
	import libcore.tzdata.testing.ZoneInfoTestHelper;
	import libcore.tzdata.update2.tools.TimeZoneDistroBuilder;

	/**
	* Tests for {@link TimeZoneDistroInstaller}.
	*/
	public class TimeZoneDistroInstallerTest extends TestCase {

	// OLDER_RULES_VERSION < SYSTEM_RULES_VERSION < NEW_RULES_VERSION < NEWER_RULES_VERSION
	private static final String OLDER_RULES_VERSION = "2030a";
	private static final String SYSTEM_RULES_VERSION = "2030b";
	private static final String NEW_RULES_VERSION = "2030c";
	private static final String NEWER_RULES_VERSION = "2030d";

	private TimeZoneDistroInstaller installer;
	private File tempDir;
	private File testInstallDir;
	private File testSystemTzDataDir;

	@Override
	public void setUp() throws Exception {
	super.setUp();
	tempDir = createDirectory("tempDir");
	testInstallDir = createDirectory("testInstall");
	testSystemTzDataDir = createDirectory("testSystemTzData");

	// Create a file to represent the tzdata file in the /system partition of the device.
	File testSystemTzDataFile = new File(testSystemTzDataDir, "tzdata");
	byte[] systemTzDataBytes = createTzData(SYSTEM_RULES_VERSION);
	createFile(testSystemTzDataFile, systemTzDataBytes);

	installer = new TimeZoneDistroInstaller(
	"TimeZoneDistroInstallerTest", testSystemTzDataFile, testInstallDir);
	}

	private static File createDirectory(String prefix) throws Exception {
	File dir = File.createTempFile(prefix, "");
	assertTrue(dir.delete());
	assertTrue(dir.mkdir());
	return dir;
	}

	@Override
	public void tearDown() throws Exception {
	if (testSystemTzDataDir.exists()) {
	FileUtils.deleteRecursive(testInstallDir);
	}
	if (testInstallDir.exists()) {
	FileUtils.deleteRecursive(testInstallDir);
	}
	if (tempDir.exists()) {
	FileUtils.deleteRecursive(tempDir);
	}
	super.tearDown();
	}

	/** Tests the an update on a device will fail if the /system tzdata file cannot be found. */
	public void testInstall_badSystemFile() throws Exception {
	File doesNotExist = new File(testSystemTzDataDir, "doesNotExist");
	TimeZoneDistroInstaller brokenSystemInstaller = new TimeZoneDistroInstaller(
	"TimeZoneDistroInstallerTest", doesNotExist, testInstallDir);
	TimeZoneDistro tzData = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);

	try {
	brokenSystemInstaller.installWithErrorCode(tzData.getBytes());
	fail();
	} catch (IOException expected) {}

	assertNoContentInstalled();
	}

	/** Tests the first successful update on a device */
	public void testInstall_successfulFirstUpdate() throws Exception {
	TimeZoneDistro distro = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);

	assertEquals(
	TimeZoneDistroInstaller.INSTALL_SUCCESS,
	installer.installWithErrorCode(distro.getBytes()));
	assertDistroInstalled(distro);
	}

	/**
	* Tests we can install an update the same version as is in /system.
	*/
	public void testInstall_successfulFirstUpdate_sameVersionAsSystem() throws Exception {
	TimeZoneDistro distro = createValidTimeZoneDistro(SYSTEM_RULES_VERSION, 1);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_SUCCESS,
	installer.installWithErrorCode(distro.getBytes()));
	assertDistroInstalled(distro);
	}

	/**
	* Tests we cannot install an update older than the version in /system.
	*/
	public void testInstall_unsuccessfulFirstUpdate_olderVersionThanSystem() throws Exception {
	TimeZoneDistro distro = createValidTimeZoneDistro(OLDER_RULES_VERSION, 1);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_FAIL_RULES_TOO_OLD,
	installer.installWithErrorCode(distro.getBytes()));
	assertNoContentInstalled();
	}

	/**
	* Tests an update on a device when there is a prior update already applied.
	*/
	public void testInstall_successfulFollowOnUpdate_newerVersion() throws Exception {
	TimeZoneDistro distro1 = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_SUCCESS,
	installer.installWithErrorCode(distro1.getBytes()));
	assertDistroInstalled(distro1);

	TimeZoneDistro distro2 = createValidTimeZoneDistro(NEW_RULES_VERSION, 2);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_SUCCESS,
	installer.installWithErrorCode(distro2.getBytes()));
	assertDistroInstalled(distro2);

	TimeZoneDistro distro3 = createValidTimeZoneDistro(NEWER_RULES_VERSION, 1);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_SUCCESS,
	installer.installWithErrorCode(distro3.getBytes()));
	assertDistroInstalled(distro3);
	}

	/**
	* Tests an update on a device when there is a prior update already applied, but the follow
	* on update is older than in /system.
	*/
	public void testInstall_unsuccessfulFollowOnUpdate_olderVersion() throws Exception {
	TimeZoneDistro distro1 = createValidTimeZoneDistro(NEW_RULES_VERSION, 2);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_SUCCESS,
	installer.installWithErrorCode(distro1.getBytes()));
	assertDistroInstalled(distro1);

	TimeZoneDistro distro2 = createValidTimeZoneDistro(OLDER_RULES_VERSION, 1);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_FAIL_RULES_TOO_OLD,
	installer.installWithErrorCode(distro2.getBytes()));
	assertDistroInstalled(distro1);
	}

	/** Tests that a distro with a missing file will not update the content. */
	public void testInstall_missingTzDataFile() throws Exception {
	TimeZoneDistro installedDistro = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_SUCCESS,
	installer.installWithErrorCode(installedDistro.getBytes()));
	assertDistroInstalled(installedDistro);

	TimeZoneDistro incompleteDistro =
	createValidTimeZoneDistroBuilder(NEWER_RULES_VERSION, 1)
	.clearTzDataForTests()
	.buildUnvalidated();
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_STRUCTURE,
	installer.installWithErrorCode(incompleteDistro.getBytes()));
	assertDistroInstalled(installedDistro);
	}

	/** Tests that a distro with a missing file will not update the content. */
	public void testInstall_missingIcuFile() throws Exception {
	TimeZoneDistro installedDistro = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_SUCCESS,
	installer.installWithErrorCode(installedDistro.getBytes()));
	assertDistroInstalled(installedDistro);

	TimeZoneDistro incompleteDistro =
	createValidTimeZoneDistroBuilder(NEWER_RULES_VERSION, 1)
	.clearIcuDataForTests()
	.buildUnvalidated();
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_STRUCTURE,
	installer.installWithErrorCode(incompleteDistro.getBytes()));
	assertDistroInstalled(installedDistro);
	}

	/**
	* Tests that an update will be unpacked even if there is a partial update from a previous run.
	*/
	public void testInstall_withWorkingDir() throws Exception {
	File workingDir = installer.getWorkingDir();
	assertTrue(workingDir.mkdir());
	createFile(new File(workingDir, "myFile"), new byte[] { 'a' });

	TimeZoneDistro distro = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_SUCCESS,
	installer.installWithErrorCode(distro.getBytes()));
	assertDistroInstalled(distro);
	}

	/**
	* Tests that a distro without a distro version file will be rejected.
	*/
	public void testInstall_withMissingDistroVersionFile() throws Exception {
	// Create a distro without a version file.
	TimeZoneDistro distro = createValidTimeZoneDistroBuilder(NEW_RULES_VERSION, 1)
	.clearVersionForTests()
	.buildUnvalidated();
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_STRUCTURE,
	installer.installWithErrorCode(distro.getBytes()));
	assertNoContentInstalled();
	}

	/**
	* Tests that a distro with an newer distro version will be rejected.
	*/
	public void testInstall_withNewerDistroVersion() throws Exception {
	// Create a distro that will appear to be newer than the one currently supported.
	TimeZoneDistro distro = createValidTimeZoneDistroBuilder(NEW_RULES_VERSION, 1)
	.replaceFormatVersionForTests(2, 1)
	.buildUnvalidated();
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_FORMAT_VERSION,
	installer.installWithErrorCode(distro.getBytes()));
	assertNoContentInstalled();
	}

	/**
	* Tests that a distro with a badly formed distro version will be rejected.
	*/
	public void testInstall_withBadlyFormedDistroVersion() throws Exception {
	// Create a distro that has an invalid major distro version. It should be 3 numeric
	// characters, "." and 3 more numeric characters.
	DistroVersion validDistroVersion = new DistroVersion(1, 1, NEW_RULES_VERSION, 1);
	byte[] invalidFormatVersionBytes = validDistroVersion.toBytes();
	invalidFormatVersionBytes[0] = 'A';

	TimeZoneDistro distro = createTimeZoneDistroWithVersionBytes(invalidFormatVersionBytes);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_STRUCTURE,
	installer.installWithErrorCode(distro.getBytes()));
	assertNoContentInstalled();
	}

	/**
	* Tests that a distro with a badly formed revision will be rejected.
	*/
	public void testInstall_withBadlyFormedRevision() throws Exception {
	// Create a distro that has an invalid revision. It should be 3 numeric characters.
	DistroVersion validDistroVersion = new DistroVersion(1, 1, NEW_RULES_VERSION, 1);
	byte[] invalidRevisionBytes = validDistroVersion.toBytes();
	invalidRevisionBytes[invalidRevisionBytes.length - 3] = 'A';

	TimeZoneDistro distro = createTimeZoneDistroWithVersionBytes(invalidRevisionBytes);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_STRUCTURE,
	installer.installWithErrorCode(distro.getBytes()));
	assertNoContentInstalled();
	}

	/**
	* Tests that a distro with a badly formed rules version will be rejected.
	*/
	public void testInstall_withBadlyFormedRulesVersion() throws Exception {
	// Create a distro that has an invalid rules version. It should be in the form "2016c".
	DistroVersion validDistroVersion = new DistroVersion(1, 1, NEW_RULES_VERSION, 1);
	byte[] invalidRulesVersionBytes = validDistroVersion.toBytes();
	invalidRulesVersionBytes[invalidRulesVersionBytes.length - 6] = 'B';

	TimeZoneDistro distro = createTimeZoneDistroWithVersionBytes(invalidRulesVersionBytes);
	assertEquals(
	TimeZoneDistroInstaller.INSTALL_FAIL_BAD_DISTRO_STRUCTURE,
	installer.installWithErrorCode(distro.getBytes()));
	assertNoContentInstalled();
	}

	public void testUninstall_noExistingDataDistro() throws Exception {
	assertFalse(installer.uninstall());
	assertNoContentInstalled();
	}

	public void testUninstall_existingDataDistro() throws Exception {
	File currentDataDir = installer.getCurrentTzDataDir();
	assertTrue(currentDataDir.mkdir());

	assertTrue(installer.uninstall());
	assertNoContentInstalled();
	}

	public void testUninstall_oldDirsAlreadyExists() throws Exception {
	File oldTzDataDir = installer.getOldTzDataDir();
	assertTrue(oldTzDataDir.mkdir());

	File currentDataDir = installer.getCurrentTzDataDir();
	assertTrue(currentDataDir.mkdir());

	assertTrue(installer.uninstall());
	assertNoContentInstalled();
	}

	public void testGetSystemRulesVersion() throws Exception {
	assertEquals(SYSTEM_RULES_VERSION, installer.getSystemRulesVersion());
	}

	private static TimeZoneDistro createValidTimeZoneDistro(
	String rulesVersion, int revision) throws Exception {
	return createValidTimeZoneDistroBuilder(rulesVersion, revision).build();
	}

	private static TimeZoneDistroBuilder createValidTimeZoneDistroBuilder(
	String rulesVersion, int revision) throws Exception {

	byte[] bionicTzData = createTzData(rulesVersion);
	byte[] icuData = new byte[] { 'a' };
	DistroVersion distroVersion = new DistroVersion(
	DistroVersion.CURRENT_FORMAT_MAJOR_VERSION,
	DistroVersion.CURRENT_FORMAT_MINOR_VERSION,
	rulesVersion,
	revision);
	return new TimeZoneDistroBuilder()
	.setDistroVersion(distroVersion)
	.setTzData(bionicTzData)
	.setIcuData(icuData);
	}

	private void assertDistroInstalled(TimeZoneDistro expectedDistro) throws Exception {
	assertTrue(testInstallDir.exists());

	File currentTzDataDir = installer.getCurrentTzDataDir();
	assertTrue(currentTzDataDir.exists());

	File distroVersionFile =
	new File(currentTzDataDir, TimeZoneDistro.DISTRO_VERSION_FILE_NAME);
	assertTrue(distroVersionFile.exists());

	File bionicFile = new File(currentTzDataDir, TimeZoneDistro.TZDATA_FILE_NAME);
	assertTrue(bionicFile.exists());

	File icuFile = new File(currentTzDataDir, TimeZoneDistro.ICU_DATA_FILE_NAME);
	assertTrue(icuFile.exists());

	// Assert getInstalledDistroVersion() is reporting correctly.
	assertEquals(expectedDistro.getDistroVersion(), installer.getInstalledDistroVersion());

	try (ZipInputStream zis = new ZipInputStream(
	new ByteArrayInputStream(expectedDistro.getBytes()))) {
	ZipEntry entry;
	while ((entry = zis.getNextEntry()) != null) {
	String entryName = entry.getName();
	File actualFile;
	if (entryName.endsWith(TimeZoneDistro.DISTRO_VERSION_FILE_NAME)) {
	actualFile = distroVersionFile;
	} else if (entryName.endsWith(TimeZoneDistro.ICU_DATA_FILE_NAME)) {
	actualFile = icuFile;
	} else if (entryName.endsWith(TimeZoneDistro.TZDATA_FILE_NAME)) {
	actualFile = bionicFile;
	} else {
	throw new AssertionFailedError("Unknown file found");
	}
	assertContentsMatches(zis, actualFile);
	}
	}

	// Also check no working directory is left lying around.
	File workingDir = installer.getWorkingDir();
	assertFalse(workingDir.exists());
	}

	private void assertContentsMatches(InputStream expected, File actual)
	throws Exception {
	byte[] actualBytes = IoUtils.readFileAsByteArray(actual.getPath());
	byte[] expectedBytes = Streams.readFullyNoClose(expected);
	assertTrue(Arrays.equals(expectedBytes, actualBytes));
	}

	private void assertNoContentInstalled() throws Exception {
	assertNull(installer.getInstalledDistroVersion());

	File currentTzDataDir = installer.getCurrentTzDataDir();
	assertFalse(currentTzDataDir.exists());

	// Also check no working directories are left lying around.
	File workingDir = installer.getWorkingDir();
	assertFalse(workingDir.exists());

	File oldDataDir = installer.getOldTzDataDir();
	assertFalse(oldDataDir.exists());
	}

	private static byte[] createTzData(String rulesVersion) {
	return new ZoneInfoTestHelper.TzDataBuilder()
	.initializeToValid()
	.setHeaderMagic("tzdata" + rulesVersion)
	.build();
	}

	private static void createFile(File file, byte[] bytes) {
	try (FileOutputStream fos = new FileOutputStream(file)) {
	fos.write(bytes);
	} catch (IOException e) {
	fail(e.getMessage());
	}
	}

	/**
	* Creates a TimeZoneDistro containing arbitrary bytes in the version file. Used for testing
	* distros with badly formed version info.
	*/
	private static TimeZoneDistro createTimeZoneDistroWithVersionBytes(byte[] versionBytes)
	throws Exception {

	// Create a valid distro, then manipulate the version file.
	TimeZoneDistro distro = createValidTimeZoneDistro(NEW_RULES_VERSION, 1);
	byte[] distroBytes = distro.getBytes();

	ByteArrayOutputStream baos = new ByteArrayOutputStream(distroBytes.length);
	try (ZipInputStream zipInputStream =
	new ZipInputStream(new ByteArrayInputStream(distroBytes));
	ZipOutputStream zipOutputStream = new ZipOutputStream(baos)) {

	ZipEntry entry;
	while ((entry = zipInputStream.getNextEntry()) != null) {
	zipOutputStream.putNextEntry(entry);
	if (entry.getName().equals(TimeZoneDistro.DISTRO_VERSION_FILE_NAME)) {
	// Replace the content.
	zipOutputStream.write(versionBytes);
	} else {
	// Just copy the content.
	Streams.copy(zipInputStream, zipOutputStream);
	}
	zipOutputStream.closeEntry();
	zipInputStream.closeEntry();
	}
	}
	return new TimeZoneDistro(baos.toByteArray());
	}
	}