javatests/com/google/android/libraries/mobiledatadownload/file/backends/AndroidUriTest.java - platform/external/mobile-data-download - Git at Google

 /*
  * Copyright 2022 Google LLC
  *
  * 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.android.libraries.mobiledatadownload.file.backends;

 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertThrows;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;

 import android.accounts.Account;
 import android.content.Context;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Build.VERSION_CODES;
 import androidx.test.core.app.ApplicationProvider;
 import com.google.common.util.concurrent.Futures;
 import com.google.thirdparty.robolectric.GoogleRobolectricTestRunner;
 import java.io.File;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.annotation.Config;

 /** Test {@link com.google.android.libraries.mobiledatadownload.file.backends.AndroidUri}. */
 @RunWith(GoogleRobolectricTestRunner.class)
 @Config(
     sdk = {VERSION_CODES.M, VERSION_CODES.N, VERSION_CODES.O},
     shadows = {})
 public final class AndroidUriTest {

   private final Context context = ApplicationProvider.getApplicationContext();

   @Test
   public void builder_unsupportedLocationSuchAsCache_throwsException() {
     File file = new File(context.getCacheDir(), "file");
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file));
   }

   @Test
   public void builder_missingAccountDirectory_throwsException() {
     File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), "module/");
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file));
   }

   @Test
   public void builder_filesLocation() {
     String filePath = "module/shared/directory/file";
     File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

     Uri uri = AndroidUri.builder(context).fromFile(file).build();
     assertThat(uri.getScheme()).isEqualTo("android");
     assertThat(uri.getAuthority()).isEqualTo(context.getPackageName());
     assertThat(uri.getPath()).isEqualTo("/files/" + filePath);
     assertThat(uri.toString())
         .isEqualTo("android://" + context.getPackageName() + "/files/" + filePath);
   }

   @Test
   public void builder_cacheLocation() {
     String filePath = "module/shared/directory/file";
     File file = new File(context.getCacheDir(), filePath);

     Uri uri = AndroidUri.builder(context).fromFile(file).build();
     assertThat(uri.getScheme()).isEqualTo("android");
     assertThat(uri.getAuthority()).isEqualTo(context.getPackageName());
     assertThat(uri.getPath()).isEqualTo("/cache/" + filePath);
     assertThat(uri.toString())
         .isEqualTo("android://" + context.getPackageName() + "/cache/" + filePath);
   }

   @Test
   public void builder_filesLocation_withEmailAccount() {
     String filePath = "module/google.com:<internal>@gmail.com/directory/file";
     File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

     Uri uri = AndroidUri.builder(context).fromFile(file).build();
     assertThat(uri.getScheme()).isEqualTo("android");
     assertThat(uri.getAuthority()).isEqualTo(context.getPackageName());
     assertThat(uri.getPath()).isEqualTo("/files/" + filePath);
     assertThat(uri.toString())
         .isEqualTo("android://" + context.getPackageName() + "/files/" + Uri.encode(filePath, "/"));
   }

   @Test
   public void builder_filesLocation_withEmptyAccountName() {
     String filePath = "module/google.com:/directory/file";
     File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

     assertThrows(
         IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file).build());
   }

   @Test
   public void builder_filesLocation_withEmptyAccountType() {
     String filePath = "module/:<internal>@gmail.com/directory/file";
     File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

     assertThrows(
         IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file).build());
   }

   @Test
   public void builder_filesLocation_withMalformedAccount() {
     String filePath = "module/MALFORMED/directory/file";
     File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

     assertThrows(
         IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file).build());
   }

   @Test
   @Config(sdk = Build.VERSION_CODES.N)
   public void builder_directBootFilesDirectory() {
     String filePath = "module/shared/directory/file";
     File root = new File(AndroidFileEnvironment.getDeviceProtectedDataDir(context), "files");
     File file = new File(root, filePath);

     Uri uri = AndroidUri.builder(context).fromFile(file).build();
     assertThat(uri.getScheme()).isEqualTo("android");
     assertThat(uri.getAuthority()).isEqualTo(context.getPackageName());
     assertThat(uri.getPath()).isEqualTo("/directboot-files/" + filePath);
     assertThat(uri.toString())
         .isEqualTo("android://" + context.getPackageName() + "/directboot-files/" + filePath);
   }

   @Test
   @Config(sdk = Build.VERSION_CODES.N)
   public void builder_directBootCacheDirectory() {
     String filePath = "module/shared/directory/file";
     File root = new File(AndroidFileEnvironment.getDeviceProtectedDataDir(context), "cache");
     File file = new File(root, filePath);

     Uri uri = AndroidUri.builder(context).fromFile(file).build();
     assertThat(uri.getScheme()).isEqualTo("android");
     assertThat(uri.getAuthority()).isEqualTo(context.getPackageName());
     assertThat(uri.getPath()).isEqualTo("/directboot-cache/" + filePath);
     assertThat(uri.toString())
         .isEqualTo("android://" + context.getPackageName() + "/directboot-cache/" + filePath);
   }

   @Test
   public void builder_allowsEmptyRelativePath() {
     String filePath = "module/shared/";
     File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);
     Uri uri = AndroidUri.builder(context).fromFile(file).build();
     assertThat(uri.getPath()).isEqualTo("/files/" + filePath);
   }

   @Test
   public void builder_unsupportedModule_throwsException() {
     String filePath = "shared/shared/file";
     File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file));
   }

   @Test
   public void builder_fromManagedSharedFile_doesNotRequireAccountManager() {
     String filePath = "/managed/module/shared/file";
     File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);
     Uri uri = AndroidUri.builder(context).fromFile(file).build();
     assertThat(uri.getPath()).isEqualTo(filePath);
   }

   @Test
   public void builder_fromManagedAccountFile_requiresAccountManager() {
     String filePath = "/managed/module/0/file";
     File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

     assertThrows(
         IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file).build());
   }

   @Test
   public void builder_fromManagedFile_readsFromAccountManager() {
     Account account = new Account("<internal>@gmail.com", "google.com");
     AccountManager mockManager = mock(AccountManager.class);
     when(mockManager.getAccount(123)).thenReturn(Futures.immediateFuture(account));

     String filePath = "/managed/module/123/file";
     File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

     Uri uri = AndroidUri.builder(context).fromFile(file, mockManager).build();
     assertThat(getPathFragment(uri, 2)).isEqualTo("google.com:<internal>@gmail.com");
   }

   @Test
   public void builder_componentsAreSetByDefault() {
     Uri uri = AndroidUri.builder(context).build();
     assertThat(uri.getScheme()).isEqualTo("android");
     assertThat(uri.getAuthority()).isEqualTo(context.getPackageName());
     assertThat(uri.getPath()).isEqualTo("/files/common/shared/");
     assertThat(uri.toString())
         .isEqualTo("android://" + context.getPackageName() + "/files/common/shared/");
   }

   @Test
   public void builder_setLocation_expectedUsage() {
     Uri uri = AndroidUri.builder(context).setInternalLocation().build();
     assertThat(getPathFragment(uri, 0)).isEqualTo("files");
   }

   @Test
   public void builder_setLocation_externalLocation() {
     Uri uri = AndroidUri.builder(context).setExternalLocation().build();
     assertThat(getPathFragment(uri, 0)).isEqualTo("external");
   }

   @Test
   public void builder_setLocation_managed() {
     Uri uri = AndroidUri.builder(context).setManagedLocation().build();
     assertThat(getPathFragment(uri, 0)).isEqualTo("managed");
   }

   @Test
   public void builder_setModule_expectedUsage() {
     Uri uri = AndroidUri.builder(context).setModule("testmodule").build();
     assertThat(getPathFragment(uri, 1)).isEqualTo("testmodule");
   }

   @Test
   public void builder_setModule_isValidated() {
     assertThrows(
         IllegalArgumentException.class, () -> AndroidUri.builder(context).setModule("").build());
   }

   @Test
   public void builder_setModule_doesNotCollideWithManagedLocation() {
     assertThrows(
         IllegalArgumentException.class,
         () -> AndroidUri.builder(context).setModule("managed").build());
   }

   @Test
   public void builder_sharedAccount_isSerializedAsShared() {
     Uri uri = AndroidUri.builder(context).setAccount(AndroidUri.SHARED_ACCOUNT).build();
     assertThat(getPathFragment(uri, 2)).isEqualTo("shared");
   }

   @Test
   public void builder_setAccount_isValidated() {
     assertThrows(
         IllegalArgumentException.class,
         () -> AndroidUri.builder(context).setAccount(new Account("", "")).build());
   }

   @Test
   public void builder_setRelativePath_expectedUsage() {
     Uri uri = AndroidUri.builder(context).setRelativePath("testfile").build();
     assertThat(getPathFragment(uri, 3)).isEqualTo("testfile");
   }

   @Test
   public void validateLocation_onlyAllowsPermittedLocations() {
     AndroidUri.validateLocation("files");
     AndroidUri.validateLocation("cache");
     AndroidUri.validateLocation("external");
     AndroidUri.validateLocation("directboot-files");
     AndroidUri.validateLocation("directboot-cache");
     AndroidUri.validateLocation("managed");
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateLocation(""));
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateLocation("other"));
   }

   @Test
   public void validateModule_disallowsReservedModules() {
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("reserved"));
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("RESERVED"));
   }

   @Test
   public void validateModule_allowsNonEmptyLowercaseLetters() {
     AndroidUri.validateModule("a");
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule(""));
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("A"));
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("Aa"));

     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("mymodule0"));
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("myModule"));
   }

   @Test
   public void validateModule_allowsInterleavedUnderscores() {
     AndroidUri.validateModule("mymodule");
     AndroidUri.validateModule("my_module");
     AndroidUri.validateModule("my_module_two");

     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("my module"));
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("my-module"));

     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("mymodule_"));
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("_mymodule"));
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("my_module_"));
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("_my_module"));
     assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("my__module"));
   }

   @Test
   public void validateRelativePath_isNoOp() {
     AndroidUri.validateRelativePath("");
     AndroidUri.validateRelativePath("myFile");
     AndroidUri.validateRelativePath("myDir/myFile");
     AndroidUri.validateRelativePath("myDir/../myFile");
     AndroidUri.validateRelativePath("/myDir/myFile");
   }

   @Test
   public void builder_setPackage_expectedUsage() {
     Uri uri = AndroidUri.builder(context).setPackage("testpackage").build();
     assertThat(uri.getAuthority()).isEqualTo("testpackage");
   }

   /**
    * Utility method to get the i'th path fragment of {@code URI}. May throw exception if the URI is
    * null, its path is null, or it does not have {@code index} path fragments.
    */
   private static String getPathFragment(Uri uri, int index) {
     // A valid path begins with "/", so +1 is required to offset the first split element ("")
     return uri.getPath().split("/")[index + 1];
   }
 }
	/*
	* Copyright 2022 Google LLC
	*
	* 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.android.libraries.mobiledatadownload.file.backends;

	import static com.google.common.truth.Truth.assertThat;
	import static org.junit.Assert.assertThrows;
	import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.when;

	import android.accounts.Account;
	import android.content.Context;
	import android.net.Uri;
	import android.os.Build;
	import android.os.Build.VERSION_CODES;
	import androidx.test.core.app.ApplicationProvider;
	import com.google.common.util.concurrent.Futures;
	import com.google.thirdparty.robolectric.GoogleRobolectricTestRunner;
	import java.io.File;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.robolectric.annotation.Config;

	/** Test {@link com.google.android.libraries.mobiledatadownload.file.backends.AndroidUri}. */
	@RunWith(GoogleRobolectricTestRunner.class)
	@Config(
	sdk = {VERSION_CODES.M, VERSION_CODES.N, VERSION_CODES.O},
	shadows = {})
	public final class AndroidUriTest {

	private final Context context = ApplicationProvider.getApplicationContext();

	@Test
	public void builder_unsupportedLocationSuchAsCache_throwsException() {
	File file = new File(context.getCacheDir(), "file");
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file));
	}

	@Test
	public void builder_missingAccountDirectory_throwsException() {
	File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), "module/");
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file));
	}

	@Test
	public void builder_filesLocation() {
	String filePath = "module/shared/directory/file";
	File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

	Uri uri = AndroidUri.builder(context).fromFile(file).build();
	assertThat(uri.getScheme()).isEqualTo("android");
	assertThat(uri.getAuthority()).isEqualTo(context.getPackageName());
	assertThat(uri.getPath()).isEqualTo("/files/" + filePath);
	assertThat(uri.toString())
	.isEqualTo("android://" + context.getPackageName() + "/files/" + filePath);
	}

	@Test
	public void builder_cacheLocation() {
	String filePath = "module/shared/directory/file";
	File file = new File(context.getCacheDir(), filePath);

	Uri uri = AndroidUri.builder(context).fromFile(file).build();
	assertThat(uri.getScheme()).isEqualTo("android");
	assertThat(uri.getAuthority()).isEqualTo(context.getPackageName());
	assertThat(uri.getPath()).isEqualTo("/cache/" + filePath);
	assertThat(uri.toString())
	.isEqualTo("android://" + context.getPackageName() + "/cache/" + filePath);
	}

	@Test
	public void builder_filesLocation_withEmailAccount() {
	String filePath = "module/google.com:<internal>@gmail.com/directory/file";
	File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

	Uri uri = AndroidUri.builder(context).fromFile(file).build();
	assertThat(uri.getScheme()).isEqualTo("android");
	assertThat(uri.getAuthority()).isEqualTo(context.getPackageName());
	assertThat(uri.getPath()).isEqualTo("/files/" + filePath);
	assertThat(uri.toString())
	.isEqualTo("android://" + context.getPackageName() + "/files/" + Uri.encode(filePath, "/"));
	}

	@Test
	public void builder_filesLocation_withEmptyAccountName() {
	String filePath = "module/google.com:/directory/file";
	File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

	assertThrows(
	IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file).build());
	}

	@Test
	public void builder_filesLocation_withEmptyAccountType() {
	String filePath = "module/:<internal>@gmail.com/directory/file";
	File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

	assertThrows(
	IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file).build());
	}

	@Test
	public void builder_filesLocation_withMalformedAccount() {
	String filePath = "module/MALFORMED/directory/file";
	File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

	assertThrows(
	IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file).build());
	}

	@Test
	@Config(sdk = Build.VERSION_CODES.N)
	public void builder_directBootFilesDirectory() {
	String filePath = "module/shared/directory/file";
	File root = new File(AndroidFileEnvironment.getDeviceProtectedDataDir(context), "files");
	File file = new File(root, filePath);

	Uri uri = AndroidUri.builder(context).fromFile(file).build();
	assertThat(uri.getScheme()).isEqualTo("android");
	assertThat(uri.getAuthority()).isEqualTo(context.getPackageName());
	assertThat(uri.getPath()).isEqualTo("/directboot-files/" + filePath);
	assertThat(uri.toString())
	.isEqualTo("android://" + context.getPackageName() + "/directboot-files/" + filePath);
	}

	@Test
	@Config(sdk = Build.VERSION_CODES.N)
	public void builder_directBootCacheDirectory() {
	String filePath = "module/shared/directory/file";
	File root = new File(AndroidFileEnvironment.getDeviceProtectedDataDir(context), "cache");
	File file = new File(root, filePath);

	Uri uri = AndroidUri.builder(context).fromFile(file).build();
	assertThat(uri.getScheme()).isEqualTo("android");
	assertThat(uri.getAuthority()).isEqualTo(context.getPackageName());
	assertThat(uri.getPath()).isEqualTo("/directboot-cache/" + filePath);
	assertThat(uri.toString())
	.isEqualTo("android://" + context.getPackageName() + "/directboot-cache/" + filePath);
	}

	@Test
	public void builder_allowsEmptyRelativePath() {
	String filePath = "module/shared/";
	File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);
	Uri uri = AndroidUri.builder(context).fromFile(file).build();
	assertThat(uri.getPath()).isEqualTo("/files/" + filePath);
	}

	@Test
	public void builder_unsupportedModule_throwsException() {
	String filePath = "shared/shared/file";
	File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file));
	}

	@Test
	public void builder_fromManagedSharedFile_doesNotRequireAccountManager() {
	String filePath = "/managed/module/shared/file";
	File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);
	Uri uri = AndroidUri.builder(context).fromFile(file).build();
	assertThat(uri.getPath()).isEqualTo(filePath);
	}

	@Test
	public void builder_fromManagedAccountFile_requiresAccountManager() {
	String filePath = "/managed/module/0/file";
	File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

	assertThrows(
	IllegalArgumentException.class, () -> AndroidUri.builder(context).fromFile(file).build());
	}

	@Test
	public void builder_fromManagedFile_readsFromAccountManager() {
	Account account = new Account("<internal>@gmail.com", "google.com");
	AccountManager mockManager = mock(AccountManager.class);
	when(mockManager.getAccount(123)).thenReturn(Futures.immediateFuture(account));

	String filePath = "/managed/module/123/file";
	File file = new File(AndroidFileEnvironment.getFilesDirWithPreNWorkaround(context), filePath);

	Uri uri = AndroidUri.builder(context).fromFile(file, mockManager).build();
	assertThat(getPathFragment(uri, 2)).isEqualTo("google.com:<internal>@gmail.com");
	}

	@Test
	public void builder_componentsAreSetByDefault() {
	Uri uri = AndroidUri.builder(context).build();
	assertThat(uri.getScheme()).isEqualTo("android");
	assertThat(uri.getAuthority()).isEqualTo(context.getPackageName());
	assertThat(uri.getPath()).isEqualTo("/files/common/shared/");
	assertThat(uri.toString())
	.isEqualTo("android://" + context.getPackageName() + "/files/common/shared/");
	}

	@Test
	public void builder_setLocation_expectedUsage() {
	Uri uri = AndroidUri.builder(context).setInternalLocation().build();
	assertThat(getPathFragment(uri, 0)).isEqualTo("files");
	}

	@Test
	public void builder_setLocation_externalLocation() {
	Uri uri = AndroidUri.builder(context).setExternalLocation().build();
	assertThat(getPathFragment(uri, 0)).isEqualTo("external");
	}

	@Test
	public void builder_setLocation_managed() {
	Uri uri = AndroidUri.builder(context).setManagedLocation().build();
	assertThat(getPathFragment(uri, 0)).isEqualTo("managed");
	}

	@Test
	public void builder_setModule_expectedUsage() {
	Uri uri = AndroidUri.builder(context).setModule("testmodule").build();
	assertThat(getPathFragment(uri, 1)).isEqualTo("testmodule");
	}

	@Test
	public void builder_setModule_isValidated() {
	assertThrows(
	IllegalArgumentException.class, () -> AndroidUri.builder(context).setModule("").build());
	}

	@Test
	public void builder_setModule_doesNotCollideWithManagedLocation() {
	assertThrows(
	IllegalArgumentException.class,
	() -> AndroidUri.builder(context).setModule("managed").build());
	}

	@Test
	public void builder_sharedAccount_isSerializedAsShared() {
	Uri uri = AndroidUri.builder(context).setAccount(AndroidUri.SHARED_ACCOUNT).build();
	assertThat(getPathFragment(uri, 2)).isEqualTo("shared");
	}

	@Test
	public void builder_setAccount_isValidated() {
	assertThrows(
	IllegalArgumentException.class,
	() -> AndroidUri.builder(context).setAccount(new Account("", "")).build());
	}

	@Test
	public void builder_setRelativePath_expectedUsage() {
	Uri uri = AndroidUri.builder(context).setRelativePath("testfile").build();
	assertThat(getPathFragment(uri, 3)).isEqualTo("testfile");
	}

	@Test
	public void validateLocation_onlyAllowsPermittedLocations() {
	AndroidUri.validateLocation("files");
	AndroidUri.validateLocation("cache");
	AndroidUri.validateLocation("external");
	AndroidUri.validateLocation("directboot-files");
	AndroidUri.validateLocation("directboot-cache");
	AndroidUri.validateLocation("managed");
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateLocation(""));
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateLocation("other"));
	}

	@Test
	public void validateModule_disallowsReservedModules() {
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("reserved"));
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("RESERVED"));
	}

	@Test
	public void validateModule_allowsNonEmptyLowercaseLetters() {
	AndroidUri.validateModule("a");
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule(""));
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("A"));
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("Aa"));

	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("mymodule0"));
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("myModule"));
	}

	@Test
	public void validateModule_allowsInterleavedUnderscores() {
	AndroidUri.validateModule("mymodule");
	AndroidUri.validateModule("my_module");
	AndroidUri.validateModule("my_module_two");

	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("my module"));
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("my-module"));

	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("mymodule_"));
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("_mymodule"));
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("my_module_"));
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("_my_module"));
	assertThrows(IllegalArgumentException.class, () -> AndroidUri.validateModule("my__module"));
	}

	@Test
	public void validateRelativePath_isNoOp() {
	AndroidUri.validateRelativePath("");
	AndroidUri.validateRelativePath("myFile");
	AndroidUri.validateRelativePath("myDir/myFile");
	AndroidUri.validateRelativePath("myDir/../myFile");
	AndroidUri.validateRelativePath("/myDir/myFile");
	}

	@Test
	public void builder_setPackage_expectedUsage() {
	Uri uri = AndroidUri.builder(context).setPackage("testpackage").build();
	assertThat(uri.getAuthority()).isEqualTo("testpackage");
	}

	/**
	* Utility method to get the i'th path fragment of {@code URI}. May throw exception if the URI is
	* null, its path is null, or it does not have {@code index} path fragments.
	*/
	private static String getPathFragment(Uri uri, int index) {
	// A valid path begins with "/", so +1 is required to offset the first split element ("")
	return uri.getPath().split("/")[index + 1];
	}
	}