You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: native.rs
    path of file: ./repos/webrtc/constraints/examples
    
    the code of the file until where you have to start completion: use std::iter::FromIterator;

use webrtc_constraints::algorithms::{
    select_settings_candidates, ClosestToIdealPolicy, DeviceInformationExposureMode,
    TieBreakingPolicy,
};
use webrtc_constraints::property::all::name::*;
use webrtc_constraints::{
    AdvancedMediaTrackConstraints, MandatoryMediaTrackConstraints, MediaTrackConstraintSet,
    MediaTrackConstraints, MediaTrackSettings, MediaTrackSupportedConstraints, ResizeMode,
    ResolvedValueConstraint, ResolvedValueRangeConstraint, ValueConstraint, ValueRangeConstraint,
};

fn main() {
    let supported_constraints =
        MediaTrackSupportedConstraints::from_iter(vec![&DEVICE_ID, &HEIGHT, &WIDTH, &RESIZE_MODE]);

    let possible_settings = vec![
        MediaTrackSettings::from_iter([
            (&DEVICE_ID, "480p".into()),
            (&HEIGHT, 480.into()),
            (&WIDTH, 720.into()),
            (&RESIZE_MODE, ResizeMode::crop_and_scale().into()),
        ]),
        MediaTrackSettings::from_iter([
            (&DEVICE_ID, "720p".into()),
            (&HEIGHT, 720.into()),
            (&WIDTH, 1280.into()),
            (&RESIZE_MODE, ResizeMode::crop_and_scale().into()),
        ]),
        MediaTrackSettings::from_iter([
            (&DEVICE_ID, "1080p".into()),
            (&HEIGHT, 1080.into()),
            
    
fn main() {
    let supported_constraints =
        MediaTrackSupportedConstraints::from_iter(vec![&DEVICE_ID, &HEIGHT, &WIDTH, &RESIZE_MODE]);

    let possible_settings = vec![
        MediaTrackSettings::from_iter([
            (&DEVICE_ID, "480p".into()),
            (&HEIGHT, 480.into()),
            (&WIDTH, 720.into()),
            (&RESIZE_MODE, ResizeMode::crop_and_scale().into()),
        ]),
        MediaTrackSettings::from_iter([
            (&DEVICE_ID, "720p".into()),
            (&HEIGHT, 720.into()),
            (&WIDTH, 1280.into()),
            (&RESIZE_MODE, ResizeMode::crop_and_scale().into()),
        ]),
        MediaTrackSettings::from_iter([
            (&DEVICE_ID, "1080p".into()),
            (&HEIGHT, 1080.into()),
            (&WIDTH, 1920.into()),
            (&RESIZE_MODE, ResizeMode::none().into()),
        ]),
        MediaTrackSettings::from_iter([
            (&DEVICE_ID, "1440p".into()),
            (&HEIGHT, 1440.into()),
            (&WIDTH, 2560.into()),
            (&RESIZE_MODE, ResizeMode::none().into()),
        ]),
        MediaTrackSettings::from_iter([
            (&DEVICE_ID, "2160p".into()),
            (&HEIGHT, 2160.into()),
            (&WIDTH, 3840.into()),
            (&RESIZE_MODE, ResizeMode::none().into()),
        ]),
    ];

    let constraints = MediaTrackConstraints {
        mandatory: MandatoryMediaTrackConstraints::from_iter([
            (
                &WIDTH,
                ValueRangeConstraint::Constraint(ResolvedValueRangeConstraint::default().max(2560))
                    .into(),
            ),
            (
                &HEIGHT,
                ValueRangeConstraint::Constraint(ResolvedValueRangeConstraint::default().max(1440))
                    .into(),
            ),
            // Unsupported constraint, which should thus get ignored:
            (
                &FRAME_RATE,
                ValueRangeConstraint::Constraint(
                    ResolvedValueRangeConstraint::default().exact(30.0),
                )
                .into(),
            ),
        ]),
        advanced: AdvancedMediaTrackConstraints::from_iter([
            // The first advanced constraint set of "exact 800p" does not match
            // any candidate and should thus get ignored by the algorithm:
            MediaTrackConstraintSet::from_iter([(
                &HEIGHT,
                ValueRangeConstraint::Constraint(
                    ResolvedValueRangeConstraint::default().exact(800),
                )
                .into(),
            )]),
            // The second advanced constraint set of "no resizing" does match
            // candidates and should thus be applied by the algorithm:
            MediaTrackConstraintSet::from_iter([(
                &RESIZE_MODE,
                ValueConstraint::Constraint(
                    ResolvedValueConstraint::default().exact(ResizeMode::none()),
                )
                .into(),
            )]),
        ]),
    };

    // Resolve bare values to proper constraints:
    let resolved_constraints = constraints.into_resolved();

    // Sanitize constraints, removing empty and unsupported constraints:
    let sanitized_constraints = resolved_constraints.to_sanitized(&supported_constraints);

    let candidates = select_settings_candidates(
        &possible_settings,
        &sanitized_constraints,
        DeviceInformationExposureMode::Exposed,
    )
    .unwrap();

    // Specify a tie-breaking policy
    //
    // A couple of basic policies are provided batteries-included,
    // but for more sophisticated needs you can implement your own `TieBreakingPolicy`:
    let tie_breaking_policy =
        ClosestToIdealPolicy::new(possible_settings[2].clone(), &supported_constraints);

    let actual = tie_breaking_policy.select_candidate(candidates);

    let expected = &possible_settings[2];

    assert_eq!(actual, expected);
}