// Copyright 2022 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use {
    crate::{
        component_instance::{ComponentInstanceInterface, ExtendedInstanceInterface},
        error::ComponentInstanceError,
    },
    anyhow::Error,
    clonable_error::ClonableError,
    fidl_fuchsia_component_resolution as fresolution, fidl_fuchsia_io as fio,
    fuchsia_zircon_status as zx,
    lazy_static::lazy_static,
    log::error,
    once_cell::sync::OnceCell,
    std::convert::TryFrom,
    std::sync::Arc,
    thiserror::Error,
    url::Url,
};

lazy_static! {
    /// A default base URL from which to parse relative component URL
    /// components.
    static ref A_BASE_URL: Url = Url::parse("relative:///").unwrap();
}

/// The response returned from a Resolver. This struct is derived from the FIDL
/// [`fuchsia.component.resolution.Component`][fidl_fuchsia_component_resolution::Component]
/// table, except that the opaque binary ComponentDecl has been deserialized and validated.
#[derive(Debug)]
pub struct ResolvedComponent {
    /// A string indicating which resolver resolved this component (for log
    /// messages and debugging only).
    pub resolved_by: String,
    /// The url used to resolve this component.
    pub resolved_url: String,
    /// The package context, from the component resolution context returned by
    /// the resolver.
    pub context_to_resolve_children: Option<ComponentResolutionContext>,
    pub decl: cm_rust::ComponentDecl,
    pub package: Option<ResolvedPackage>,
    pub config_values: Option<cm_rust::ValuesData>,
}

/// The response returned from a Resolver. This struct is derived from the FIDL
/// [`fuchsia.component.resolution.Package`][fidl_fuchsia_component_resolution::Package]
/// table.
#[derive(Debug)]
pub struct ResolvedPackage {
    /// The package url.
    pub url: String,
    /// The package directory client proxy.
    pub directory: fidl::endpoints::ClientEnd<fio::DirectoryMarker>,
}

impl TryFrom<fresolution::Package> for ResolvedPackage {
    type Error = ResolverError;

    fn try_from(package: fresolution::Package) -> Result<Self, Self::Error> {
        Ok(ResolvedPackage {
            url: package.url.ok_or(ResolverError::PackageUrlMissing)?,
            directory: package.directory.ok_or(ResolverError::PackageDirectoryMissing)?,
        })
    }
}

/// When resolving a component, the resolver returns a PackageContext, which it
/// may use to resolve relative path URLs. The value is resolver-specific, so
/// a resolver that doesn't support relative path resolution can return any
/// value (typically an empty `Vec`).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ComponentResolutionContext(pub Vec<u8>);

impl ComponentResolutionContext {
    /// Converts this ComponentResolutionContext into a byte vector, which can be passed
    /// to a `Resolver::ResolveWithContext()` request with a relative component
    /// URL.
    pub fn into_bytes(self) -> Vec<u8> {
        self.0
    }

    /// Returns a reference to the underlying byte slice.
    pub fn as_bytes(&self) -> &[u8] {
        &self.0
    }
}

impl From<Vec<u8>> for ComponentResolutionContext {
    fn from(context: Vec<u8>) -> ComponentResolutionContext {
        ComponentResolutionContext(context)
    }
}

impl From<&[u8]> for ComponentResolutionContext {
    fn from(context: &[u8]) -> ComponentResolutionContext {
        ComponentResolutionContext(Vec::from(context))
    }
}

impl From<ComponentResolutionContext> for Vec<u8> {
    fn from(context: ComponentResolutionContext) -> Vec<u8> {
        context.into_bytes()
    }
}

impl From<&ComponentResolutionContext> for Vec<u8> {
    fn from(context: &ComponentResolutionContext) -> Vec<u8> {
        context.clone().into_bytes()
    }
}

impl<'a> From<&'a ComponentResolutionContext> for &'a [u8] {
    fn from(context: &'a ComponentResolutionContext) -> &'a [u8] {
        context.as_bytes()
    }
}

/// Provides the `ComponentAddress` and context for resolving the child that was
/// passed to `from_child()` to create this `ResolvedParentComponent`.
#[derive(Debug, Clone, PartialEq, Eq)]
struct ResolvedParentComponent {
    /// The parent address, needed for relative path URLs (to get the
    /// scheme used to find the required `Resolver`), or for relative resource
    /// URLs (which will clone the parent's address, but replace the resource).
    pub address: ComponentAddress,
    /// The parent's resolution_context, required for resolving children using
    /// a relative path component URLs.
    pub context_to_resolve_children: Option<ComponentResolutionContext>,
}

impl ResolvedParentComponent {
    /// Creates a `ResolvedParentComponent` from one of its child components.
    pub async fn from_child<C: ComponentInstanceInterface>(
        component: &Arc<C>,
    ) -> Result<Self, ResolverError> {
        if let ExtendedInstanceInterface::Component(parent_component) =
            component.try_get_parent().map_err(|err| {
                ResolverError::no_parent_context(anyhow::format_err!(
                    "component {} at {} has no parent for context: {:?}",
                    component.url(),
                    component.abs_moniker(),
                    err
                ))
            })?
        {
            let resolved_parent = parent_component.lock_resolved_state().await?;
            Ok(Self {
                address: resolved_parent.address(),
                context_to_resolve_children: resolved_parent.context_to_resolve_children(),
            })
        } else {
            Err(ResolverError::no_parent_context(anyhow::format_err!(
                "component {} has no parent for context: {}",
                component.url(),
                component.abs_moniker()
            )))
        }
    }
}

/// Indicates the kind of `ComponentAddress`, and holds `ComponentAddress`
/// properties specific to its kind. Note that there is no kind for a relative
/// resource component URL (a URL that only contains a resource fragment, such
/// as `#meta/comp.cm`) because `ComponentAddress::from()` will translate a
/// resource fragment component URL into one of the fully-resolvable
/// `ComponentAddressKind`s.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ComponentAddressKind {
    /// A fully-qualified component URL, including scheme and host; for example,
    /// "fuchsia-pkg://fuchsia.com/some_package#meta/my_component.cm". Host may
    /// be empty. The query string (excluding the question mark (`?`) prefix)
    /// is optional, and only an absolute component URL may include a query.
    /// `ComponentAddress` does not constrain the value of the query string.
    /// They may be invalid for some resolvers. Some resolvers may support a
    /// query string of the form `hash=<hex-package-merkle>`.
    Absolute { host: String, some_query: Option<String> },

    /// A relative Component URL, starting with the package path; for example a
    /// subpackage relative URL such as "needed_package#meta/dep_component.cm".
    RelativePath {
        /// An opaque value (from the perspective of component resolution)
        /// required by the resolver when resolving a relative package path.
        /// For a given child component, this property is populated from a
        /// parent component's `resolution_context`, as returned by the parent
        /// component's resolver.
        context: ComponentResolutionContext,
    },
}

#[derive(Debug, Clone, Eq)]
pub struct ComponentAddress {
    /// The kind of `ComponentAddress` (`Absolute` or `RelativePath`) with
    /// kind-specific additional properties.
    kind: ComponentAddressKind,

    /// The scheme of an ancestor component's URL, used to identify the
    /// `Resolver` in a `ResolverRegistry`.
    scheme: String,

    /// The path part of the component URL. For `RelativePath`, this path MUST
    /// NOT start with a slash (`/`). For subpackages, the path MUST contain
    /// exactly one path segment (no slashes).
    path: String,

    /// The URI fragment used to identify a resource in a package. For
    /// components, this is the component manifest path. For component URLs, the
    /// path MUST NOT start with a pound sign (`#`) or slash (`/`).
    some_resource: Option<String>,

    /// The given URL used to compute the ComponentAddress, which may have
    /// required additional information from its parent component.
    some_original_url: Option<String>,

    /// Holds a resolver-ready computed URL string.
    url: OnceCell<String>,
}

/// Ignore `some_original_url` and `url` when comparing `ComponentAddress`
/// instances.
impl PartialEq for ComponentAddress {
    fn eq(&self, other: &Self) -> bool {
        let ComponentAddress { kind, scheme, path, some_resource, some_original_url: _, url: _ } =
            other;
        &self.kind == kind
            && &self.scheme == scheme
            && &self.path == path
            && &self.some_resource == some_resource
    }
}

impl ComponentAddress {
    /// Creates a new `ComponentAddress` of the `Absolute` kind.
    pub fn new_absolute(
        scheme: &str,
        host: &str,
        path: &str,
        some_query: Option<&str>,
        some_resource: Option<&str>,
    ) -> Self {
        Self {
            kind: ComponentAddressKind::Absolute {
                host: host.to_owned(),
                some_query: some_query.map(str::to_string),
            },
            scheme: scheme.to_owned(),
            path: path.to_owned(),
            some_resource: some_resource.map(str::to_string),
            some_original_url: None,
            url: OnceCell::new(),
        }
    }

    /// Creates a new `ComponentAddress` of the `RelativePath` kind.
    pub fn new_relative_path(
        path: &str,
        some_resource: Option<&str>,
        scheme: &str,
        context: ComponentResolutionContext,
    ) -> Self {
        Self {
            kind: ComponentAddressKind::RelativePath { context },
            scheme: scheme.to_owned(),
            path: path.to_owned(),
            some_resource: some_resource.map(str::to_string),
            some_original_url: None,
            url: OnceCell::new(),
        }
    }

    /// Parse the given absolute `component_url` and create a `ComponentAddress`
    /// with kind `Absolute`.
    pub fn from_absolute_url(component_url: &str) -> Result<Self, ResolverError> {
        let url = match Url::parse(component_url) {
            Ok(url) => url,
            Err(url::ParseError::RelativeUrlWithoutBase) => {
                return Err(ResolverError::RelativeUrlNotExpected(component_url.to_string()))
            }
            Err(err) => return Err(ResolverError::malformed_url(err)),
        };
        let path = &url.path()[1..]; // skip leading "/"
        let host = url.host_str().ok_or_else(|| {
            ResolverError::malformed_url(anyhow::format_err!(
                "parsed `host` was invalid (`None`) from: {}",
                component_url
            ))
        })?;
        let mut address = Self::new_absolute(url.scheme(), host, path, url.query(), url.fragment());
        address.some_original_url = Some(component_url.to_owned());
        Ok(address)
    }

    /// Parse the given `component_url` to determine if it is an absolute URL,
    /// a relative subpackage URL, or a relative resource URL, and return the
    /// corresponding `ComponentAddress` enum variant and value. If the URL is
    /// relative, use the component instance to get the required resolution
    /// context from the component's parent.
    pub async fn from<C: ComponentInstanceInterface>(
        component_url: &str,
        component: &Arc<C>,
    ) -> Result<Self, ResolverError> {
        let result = Self::from_absolute_url(component_url);
        if !matches!(result, Err(ResolverError::RelativeUrlNotExpected(_))) {
            return result;
        }
        let url = parse_relative_url(component_url)?;
        let path = &url.path()[1..]; // skip leading "/"
        if url.fragment().is_none() && path.is_empty() {
            return Err(ResolverError::malformed_url(anyhow::format_err!("{}", component_url)));
        }
        if url.query().is_some() {
            return Err(ResolverError::malformed_url(anyhow::format_err!(
                "Query strings are not allowed in relative component URLs: {}",
                component_url
            )));
        }
        let resolved_parent = ResolvedParentComponent::from_child(component).await?;
        let mut address = if path.is_empty() {
            // The `component_url` had only a fragment, so the new
            // address will be the same as it's parent (for example, the
            // same package), except for its resource.
            resolved_parent.address.clone_with_new_resource(url.fragment())
        } else {
            // The `component_url` starts with a relative path (for
            // example, a subpackage name). Create a `RelativePath`
            // address, and resolve it using the
            // `context_to_resolve_children`, from this component's
            // parent.
            Self::new_relative_path(
                path,
                url.fragment(),
                resolved_parent.address.scheme(),
                resolved_parent.context_to_resolve_children.clone().ok_or_else(|| {
                    ResolverError::RelativeUrlMissingContext(format!(
                        "relative path component URL '{}' cannot be resolved because it's parent/ancestor did not provide a resolution context: {:?}",
                         component_url, resolved_parent.address
                    ))
                })?,
            )
        };
        address.some_original_url = Some(component_url.to_owned());
        Ok(address)
    }

    /// Creates a new `ComponentAddress` from `self` by replacing only the
    /// component URL resource.
    pub fn clone_with_new_resource(&self, some_resource: Option<&str>) -> Self {
        Self {
            kind: self.kind.clone(),
            scheme: self.scheme.clone(),
            path: self.path.clone(),
            some_resource: some_resource.map(str::to_string),
            some_original_url: None,
            url: OnceCell::new(),
        }
    }

    /// Returns the variant, which is `Absolute` or `RelativePath`.
    pub fn kind(&self) -> &ComponentAddressKind {
        &self.kind
    }

    /// True if the `kind()` is `Absolute`.
    pub fn is_absolute(&self) -> bool {
        matches!(self.kind, ComponentAddressKind::Absolute { .. })
    }

    /// True if the `kind()` is `RelativePath`.
    pub fn is_relative_path(&self) -> bool {
        matches!(self.kind, ComponentAddressKind::RelativePath { .. })
    }

    /// Returns the optional host value for an `Absolute` component URL.
    ///
    /// Panics if called for a `RelativePath` component address.
    pub fn host(&self) -> &str {
        if let ComponentAddressKind::Absolute { host, .. } = &self.kind {
            host
        } else {
            panic!("host() is only valid for `ComponentAddressKind::Absolute");
        }
    }

    /// Returns the `ComponentResolutionContext` value required to resolve for a
    /// `RelativePath` component URL.
    ///
    /// Panics if called for an `Absolute` component address.
    pub fn context(&self) -> &ComponentResolutionContext {
        if let ComponentAddressKind::RelativePath { context } = &self.kind {
            &context
        } else {
            panic!("host() is only valid for `ComponentAddressKind::Absolute");
        }
    }

    /// Returns the URL scheme either provided for an `Absolute` URL or derived
    /// from the component's parent. The scheme is used to look up a registered
    /// resolver, when resolving the component.
    pub fn scheme(&self) -> &str {
        &self.scheme
    }

    /// Returns the URL path.
    pub fn path(&self) -> &str {
        &self.path
    }

    /// Returns the optional query value for an `Absolute` component URL.
    /// Always returns `None` for `Relative` component URLs.
    pub fn query(&self) -> Option<&str> {
        if let ComponentAddressKind::Absolute { some_query, .. } = &self.kind {
            some_query.as_deref()
        } else {
            None
        }
    }

    /// Returns the optional component resource, from the URL fragment.
    pub fn resource(&self) -> Option<&str> {
        self.some_resource.as_deref()
    }

    /// Returns the original URL, if this `ComponentAddress` was created by
    /// calling `ComponentAddress::from(<original_url>, ...)`.
    pub fn original_url(&self) -> Option<&str> {
        self.some_original_url.as_deref()
    }

    /// Returns the resolver-ready URL string and, if it is a `RelativePath`,
    /// `Some(context)`, or `None` for an `Absolute` address.
    pub fn url(&self) -> &str {
        let url = self.url.get_or_init(|| match &self.kind {
            ComponentAddressKind::Absolute { host, some_query } => {
                let path = if self.path.is_empty() && !host.is_empty() {
                    "".to_string()
                } else {
                    format!("/{}", self.path)
                };
                format!(
                    "{}://{}{}{}{}",
                    self.scheme,
                    host,
                    path,
                    if let Some(query) = some_query {
                        format!("?{}", query)
                    } else {
                        "".to_string()
                    },
                    if let Some(resource) = &self.some_resource {
                        format!("#{}", resource)
                    } else {
                        "".to_string()
                    },
                )
            }
            ComponentAddressKind::RelativePath { .. } => {
                if let Some(resource) = &self.some_resource {
                    format!("{}#{}", self.path, resource)
                } else {
                    format!("{}", self.path)
                }
            }
        });
        url
    }

    /// Returns the `url()` and `Some(context)` for resolving the URL,
    /// if the kind is `RelativePath` (or `None` if `Absolute`).
    pub fn to_url_and_context(&self) -> (&str, Option<&ComponentResolutionContext>) {
        let some_context = match &self.kind {
            ComponentAddressKind::Absolute { .. } => None,
            ComponentAddressKind::RelativePath { context } => Some(context),
        };
        (self.url(), some_context)
    }
}

fn parse_relative_url(component_url: &str) -> Result<Url, ResolverError> {
    match Url::parse(component_url) {
        Ok(_) => Err(ResolverError::malformed_url(anyhow::format_err!(
            "Error parsing a relative URL given absolute URL: {}",
            component_url,
        ))),
        Err(url::ParseError::RelativeUrlWithoutBase) => {
            A_BASE_URL.join(component_url).map_err(|err| {
                ResolverError::malformed_url(anyhow::format_err!(
                    "Error parsing relative component URL {}: {:?}",
                    component_url,
                    err
                ))
            })
        }
        Err(err) => Err(ResolverError::malformed_url(anyhow::format_err!(
            "Unexpected error while parsing component_url {}: {:?}",
            component_url,
            err,
        ))),
    }
}

/// Errors produced by built-in `Resolver`s and `resolving` APIs.
#[derive(Debug, Error, Clone)]
pub enum ResolverError {
    #[error("an unexpected error occurred: {0}")]
    Internal(#[source] ClonableError),
    #[error("an IO error occurred: {0}")]
    Io(#[source] ClonableError),
    #[error("component manifest not found: {0}")]
    ManifestNotFound(#[source] ClonableError),
    #[error("package not found: {0}")]
    PackageNotFound(#[source] ClonableError),
    #[error("component manifest invalid: {0}")]
    ManifestInvalid(#[source] ClonableError),
    #[error("config values file invalid: {0}")]
    ConfigValuesInvalid(#[source] ClonableError),
    #[error("failed to read manifest: {0}")]
    ManifestIo(zx::Status),
    #[error("failed to read config values: {0}")]
    ConfigValuesIo(zx::Status),
    #[error("Model not available")]
    ModelNotAvailable,
    #[error("scheme not registered")]
    SchemeNotRegistered,
    #[error("malformed url: {0}")]
    MalformedUrl(#[source] ClonableError),
    #[error("relative url requires a parent component with resolution context: {0}")]
    NoParentContext(#[source] ClonableError),
    #[error("package URL missing")]
    PackageUrlMissing,
    #[error("package directory handle missing")]
    PackageDirectoryMissing,
    #[error("url missing resource")]
    UrlMissingResource,
    #[error("a relative URL was not expected: {0}")]
    RelativeUrlNotExpected(String),
    #[error("failed to route resolver capability: {0}")]
    RoutingError(#[source] ClonableError),
    #[error("a resolver resolved a component but did not return its required context")]
    ResolveMustReturnContext,
    #[error("a context is required to resolve relative url: {0}")]
    RelativeUrlMissingContext(String),
    #[error("this component resolver does not resolve relative path component URLs: {0}")]
    UnexpectedRelativePath(String),
    #[error("error creating a resolution context: {0}")]
    CreatingContext(String),
    #[error("error reading a resolution context: {0}")]
    ReadingContext(String),
    #[error("the remote resolver returned invalid data")]
    RemoteInvalidData,
    #[error("an error occurred sending a FIDL request to the remote resolver: {0}")]
    FidlError(#[source] ClonableError),
}

impl ResolverError {
    pub fn internal(err: impl Into<Error>) -> Self {
        Self::Internal(err.into().into())
    }

    pub fn io(err: impl Into<Error>) -> Self {
        Self::Io(err.into().into())
    }

    pub fn manifest_not_found(err: impl Into<Error>) -> Self {
        Self::ManifestNotFound(err.into().into())
    }

    pub fn package_not_found(err: impl Into<Error>) -> Self {
        Self::PackageNotFound(err.into().into())
    }

    pub fn manifest_invalid(err: impl Into<Error>) -> Self {
        Self::ManifestInvalid(err.into().into())
    }

    pub fn config_values_invalid(err: impl Into<Error>) -> Self {
        Self::ConfigValuesInvalid(err.into().into())
    }

    pub fn malformed_url(err: impl Into<Error>) -> Self {
        Self::MalformedUrl(err.into().into())
    }

    pub fn no_parent_context(err: impl Into<Error>) -> Self {
        Self::NoParentContext(err.into().into())
    }

    pub fn routing_error(err: impl Into<Error>) -> Self {
        Self::RoutingError(err.into().into())
    }

    pub fn fidl_error(err: impl Into<Error>) -> Self {
        Self::FidlError(err.into().into())
    }
}

impl From<fresolution::ResolverError> for ResolverError {
    fn from(err: fresolution::ResolverError) -> ResolverError {
        match err {
            fresolution::ResolverError::Internal => ResolverError::internal(RemoteError(err)),
            fresolution::ResolverError::Io => ResolverError::io(RemoteError(err)),
            fresolution::ResolverError::PackageNotFound
            | fresolution::ResolverError::NoSpace
            | fresolution::ResolverError::ResourceUnavailable
            | fresolution::ResolverError::NotSupported => {
                ResolverError::package_not_found(RemoteError(err))
            }
            fresolution::ResolverError::ManifestNotFound => {
                ResolverError::manifest_not_found(RemoteError(err))
            }
            fresolution::ResolverError::InvalidArgs => {
                ResolverError::malformed_url(RemoteError(err))
            }
            fresolution::ResolverError::InvalidManifest => {
                ResolverError::ManifestInvalid(anyhow::Error::from(RemoteError(err)).into())
            }
            fresolution::ResolverError::ConfigValuesNotFound => {
                ResolverError::ConfigValuesIo(zx::Status::NOT_FOUND)
            }
        }
    }
}

impl From<ComponentInstanceError> for ResolverError {
    fn from(err: ComponentInstanceError) -> ResolverError {
        use ComponentInstanceError::*;
        match &err {
            ComponentManagerInstanceUnavailable {}
            | InstanceNotFound { .. }
            | PolicyCheckerNotFound { .. }
            | ComponentIdIndexNotFound { .. }
            | ResolveFailed { .. }
            | UnresolveFailed { .. } => {
                ResolverError::Internal(ClonableError::from(anyhow::format_err!("{:?}", err)))
            }
            NoAbsoluteUrl { .. } => ResolverError::NoParentContext(ClonableError::from(
                anyhow::format_err!("{:?}", err),
            )),
            MalformedUrl { .. } => {
                ResolverError::MalformedUrl(ClonableError::from(anyhow::format_err!("{:?}", err)))
            }
        }
    }
}

#[derive(Error, Clone, Debug)]
#[error("remote resolver responded with {0:?}")]
struct RemoteError(fresolution::ResolverError);

#[cfg(test)]
mod tests {
    use {super::*, assert_matches::assert_matches, fidl::endpoints::create_endpoints};

    #[test]
    fn test_resolved_package() -> anyhow::Result<()> {
        let url = "some_url".to_string();
        let (dir_client, _) =
            create_endpoints::<fio::DirectoryMarker>().expect("failed to create Directory proxy");
        let fidl_package = fresolution::Package {
            url: Some(url.clone()),
            directory: Some(dir_client),
            ..fresolution::Package::EMPTY
        };
        let resolved_package = ResolvedPackage::try_from(fidl_package)?;
        assert_eq!(resolved_package.url, url);
        Ok(())
    }

    #[test]
    fn test_component_address() -> anyhow::Result<()> {
        let address =
            ComponentAddress::from_absolute_url("some-scheme://fuchsia.com/package#meta/comp.cm")?;
        if let ComponentAddressKind::Absolute { host, some_query } = address.kind() {
            assert_eq!(host.as_str(), "fuchsia.com");
            assert_eq!(some_query, &None);
        }
        assert!(address.is_absolute());
        assert_eq!(address.host(), "fuchsia.com");
        assert_eq!(address.scheme(), "some-scheme");
        assert_eq!(address.path(), "package");
        assert_eq!(address.query(), None);
        assert_eq!(address.resource(), Some("meta/comp.cm"));
        assert_eq!(address.original_url(), Some("some-scheme://fuchsia.com/package#meta/comp.cm"));
        assert_eq!(address.url(), "some-scheme://fuchsia.com/package#meta/comp.cm");
        assert_matches!(
            address.to_url_and_context(),
            ("some-scheme://fuchsia.com/package#meta/comp.cm", None)
        );

        let abs_address = ComponentAddress::new_absolute(
            "some-scheme",
            "fuchsia.com",
            "package",
            None,
            Some("meta/comp.cm"),
        );
        // Note that `url()` has been called on `address` but not on
        // `abs_address`, and `original_url()` differences should be ignored
        // when comparing.
        assert_eq!(abs_address, address);

        assert_eq!(abs_address, address);
        if let ComponentAddressKind::Absolute { host, .. } = abs_address.kind() {
            assert_eq!(host.as_str(), "fuchsia.com");
        }
        assert!(abs_address.is_absolute());
        assert_eq!(abs_address.host(), "fuchsia.com");
        assert_eq!(abs_address.scheme(), "some-scheme");
        assert_eq!(abs_address.path(), "package");
        assert_eq!(abs_address.query(), None);
        assert_eq!(abs_address.resource(), Some("meta/comp.cm"));
        assert_eq!(abs_address.url(), "some-scheme://fuchsia.com/package#meta/comp.cm");
        assert_matches!(
            abs_address.to_url_and_context(),
            ("some-scheme://fuchsia.com/package#meta/comp.cm", None)
        );

        let cloned_address = abs_address.clone();
        assert_eq!(abs_address, cloned_address);

        let address2 = abs_address.clone_with_new_resource(Some("meta/other_comp.cm"));
        assert_ne!(address2, abs_address);
        assert!(address2.is_absolute());
        assert_eq!(address2.resource(), Some("meta/other_comp.cm"));
        assert_eq!(address2.scheme(), "some-scheme");
        assert_eq!(address2.host(), "fuchsia.com");
        assert_eq!(address2.path(), "package");
        assert_eq!(address2.query(), None);

        let rel_address = ComponentAddress::new_relative_path(
            "subpackage",
            Some("meta/subcomp.cm"),
            "some-scheme",
            ComponentResolutionContext(vec![b'4', b'5', b'6']),
        );
        if let ComponentAddressKind::RelativePath { context } = rel_address.kind() {
            assert_eq!(context.as_bytes(), &vec![b'4', b'5', b'6']);
        }
        assert!(rel_address.is_relative_path());
        assert_eq!(rel_address.context().as_bytes(), &vec![b'4', b'5', b'6']);
        assert_eq!(rel_address.original_url(), None);
        assert_eq!(rel_address.url(), "subpackage#meta/subcomp.cm");
        assert_eq!(
            rel_address.to_url_and_context(),
            (
                "subpackage#meta/subcomp.cm",
                Some(&ComponentResolutionContext(vec![b'4', b'5', b'6']))
            )
        );

        let rel_address2 = rel_address.clone_with_new_resource(Some("meta/other_subcomp.cm"));
        assert_ne!(rel_address2, rel_address);
        assert!(rel_address2.is_relative_path());
        assert_eq!(rel_address2.context().as_bytes(), &vec![b'4', b'5', b'6']);
        assert_eq!(rel_address2.original_url(), None);
        assert_eq!(rel_address2.url(), "subpackage#meta/other_subcomp.cm");
        assert_eq!(
            rel_address2.to_url_and_context(),
            (
                "subpackage#meta/other_subcomp.cm",
                Some(&ComponentResolutionContext(vec![b'4', b'5', b'6']))
            )
        );

        let address = ComponentAddress::from_absolute_url("fuchsia-boot:///#meta/root.cm")?;
        if let ComponentAddressKind::Absolute { host, .. } = address.kind() {
            assert_eq!(host.as_str(), "");
        }
        assert!(address.is_absolute());
        assert_eq!(address.host(), "");
        assert_eq!(address.scheme(), "fuchsia-boot");
        assert_eq!(address.path(), "");
        assert_eq!(address.query(), None);
        assert_eq!(address.resource(), Some("meta/root.cm"));
        assert_eq!(address.original_url(), Some("fuchsia-boot:///#meta/root.cm"));
        assert_eq!(address.url(), "fuchsia-boot:///#meta/root.cm");
        assert_matches!(address.to_url_and_context(), ("fuchsia-boot:///#meta/root.cm", None));

        let address = ComponentAddress::from_absolute_url(
            "fuchsia-pkg://fuchsia.com/package?hash=cafe0123#meta/comp.cm",
        )?;
        if let ComponentAddressKind::Absolute { host, some_query } = address.kind() {
            assert_eq!(host.as_str(), "fuchsia.com");
            assert_eq!(some_query.as_deref(), Some("hash=cafe0123"));
        }
        assert!(address.is_absolute());
        assert_eq!(address.host(), "fuchsia.com");
        assert_eq!(address.scheme(), "fuchsia-pkg");
        assert_eq!(address.path(), "package");
        assert_eq!(address.resource(), Some("meta/comp.cm"));
        assert_eq!(address.query(), Some("hash=cafe0123"));
        assert_eq!(
            address.original_url(),
            Some("fuchsia-pkg://fuchsia.com/package?hash=cafe0123#meta/comp.cm")
        );
        assert_eq!(address.url(), "fuchsia-pkg://fuchsia.com/package?hash=cafe0123#meta/comp.cm");
        assert_matches!(
            address.to_url_and_context(),
            ("fuchsia-pkg://fuchsia.com/package?hash=cafe0123#meta/comp.cm", None)
        );

        Ok(())
    }
}