test_range_and_continuation.rs

fn no_subspace_start_end_forward() -> Result<(), Failed> {
    let rt = Builder::new_current_thread().build()?;

    let fdb_database_ref = unsafe { FDB_DATABASE.as_ref().unwrap() };

    rt.block_on({
        let fdb_database = fdb_database_ref.clone();
        async move {
            fdb_database
                .read(|tr| async move {
                    let maybe_subspace = None;
                    let key_range = KeyRange::new(KeyLowEndpoint::Start, KeyHighEndpoint::End);
                    let continuation = None;
                    let reverse = false;

                    let range = key_value_cursor_builder_build_range(
                        &maybe_subspace,
                        key_range,
                        continuation,
                        reverse,
                    )?;

                    let (range_begin, range_end) = range.clone().into_parts();
                    assert_eq!(range_begin, Key::from(Bytes::new()));
                    assert_eq!(range_end, Key::from(Bytes::from_static(b"\xFF")));

                    let mut range_options = RangeOptions::default();
                    range_options.set_reverse(reverse);

                    let (range_begin, range_end) = range.into_parts();

                    let mut range_stream = tr.get_range(
                        KeySelector::first_greater_or_equal(range_begin),
                        KeySelector::first_greater_or_equal(range_end),
                        range_options,
                    );

                    for i in 0x00..=0x09 {
                        // Safety: If `unwrap()` fails, then its a
                        //         bug.
                        let x = range_stream.next().await.unwrap();

                        let (key, value) = x?.into_parts();
                        assert_eq!(key, Key::from(Bytes::from(vec![i])));
                        assert_eq!(value, Value::from(Bytes::from(format!("value{}", i))));
                    }

                    Ok(())
                })
                .await?;

            Result::<(), Box<dyn Error>>::Ok(())
        }
    })?;

    Ok(())
}

fn no_subspace_start_end_forward_begin_marker() -> Result<(), Failed> {
    let rt = Builder::new_current_thread().build()?;

    let fdb_database_ref = unsafe { FDB_DATABASE.as_ref().unwrap() };

    rt.block_on({
        let fdb_database = fdb_database_ref.clone();
        async move {
            fdb_database
                .read(|tr| async move {
                    let maybe_subspace = None;
                    let key_range = KeyRange::new(KeyLowEndpoint::Start, KeyHighEndpoint::End);
                    let continuation = Some(key_value_continuation_v0_begin_marker_bytes()?);
                    let reverse = false;

                    let range = key_value_cursor_builder_build_range(
                        &maybe_subspace,
                        key_range,
                        continuation,
                        reverse,
                    )?;

                    let (range_begin, range_end) = range.clone().into_parts();
                    assert_eq!(range_begin, Key::from(Bytes::new()));
                    assert_eq!(range_end, Key::from(Bytes::from_static(b"\xFF")));

                    let mut range_options = RangeOptions::default();
                    range_options.set_reverse(reverse);

                    let (range_begin, range_end) = range.into_parts();

                    let mut range_stream = tr.get_range(
                        KeySelector::first_greater_or_equal(range_begin),
                        KeySelector::first_greater_or_equal(range_end),
                        range_options,
                    );

                    for i in 0x00..=0x09 {
                        // Safety: If `unwrap()` fails, then its a
                        //         bug.
                        let x = range_stream.next().await.unwrap();

                        let (key, value) = x?.into_parts();
                        assert_eq!(key, Key::from(Bytes::from(vec![i])));
                        assert_eq!(value, Value::from(Bytes::from(format!("value{}", i))));
                    }

                    Ok(())
                })
                .await?;

            Result::<(), Box<dyn Error>>::Ok(())
        }
    })?;

    Ok(())
}

fn no_subspace_start_end_reverse() -> Result<(), Failed> {
    let rt = Builder::new_current_thread().build()?;

    let fdb_database_ref = unsafe { FDB_DATABASE.as_ref().unwrap() };

    rt.block_on({
        let fdb_database = fdb_database_ref.clone();
        async move {
            fdb_database
                .read(|tr| async move {
                    let maybe_subspace = None;
                    let key_range = KeyRange::new(KeyLowEndpoint::Start, KeyHighEndpoint::End);
                    let continuation = None;
                    let reverse = true;

                    let range = key_value_cursor_builder_build_range(
                        &maybe_subspace,
                        key_range,
                        continuation,
                        reverse,
                    )?;

                    let (range_begin, range_end) = range.clone().into_parts();
                    assert_eq!(range_begin, Key::from(Bytes::new()));
                    assert_eq!(range_end, Key::from(Bytes::from_static(b"\xFF")));

                    let mut range_options = RangeOptions::default();
                    range_options.set_reverse(reverse);

                    let (range_begin, range_end) = range.into_parts();

                    let mut range_stream = tr.get_range(
                        KeySelector::first_greater_or_equal(range_begin),
                        KeySelector::first_greater_or_equal(range_end),
                        range_options,
                    );

                    for i in (0x00..=0x09).rev() {
                        // Safety: If `unwrap()` fails, then its a
                        //         bug.
                        let x = range_stream.next().await.unwrap();

                        let (key, value) = x?.into_parts();
                        assert_eq!(key, Key::from(Bytes::from(vec![i])));
                        assert_eq!(value, Value::from(Bytes::from(format!("value{}", i))));
                    }

                    Ok(())
                })
                .await?;

            Result::<(), Box<dyn Error>>::Ok(())
        }
    })?;

    Ok(())
}

fn no_subspace_start_end_reverse_begin_marker() -> Result<(), Failed> {
    let rt = Builder::new_current_thread().build()?;

    let fdb_database_ref = unsafe { FDB_DATABASE.as_ref().unwrap() };

    rt.block_on({
        let fdb_database = fdb_database_ref.clone();
        async move {
            fdb_database
                .read(|tr| async move {
                    let maybe_subspace = None;
                    let key_range = KeyRange::new(KeyLowEndpoint::Start, KeyHighEndpoint::End);
                    let continuation = Some(key_value_continuation_v0_begin_marker_bytes()?);
                    let reverse = true;

                    let range = key_value_cursor_builder_build_range(
                        &maybe_subspace,
                        key_range,
                        continuation,
                        reverse,
                    )?;

                    let (range_begin, range_end) = range.clone().into_parts();
                    assert_eq!(range_begin, Key::from(Bytes::new()));
                    assert_eq!(range_end, Key::from(Bytes::from_static(b"\xFF")));

                    let mut range_options = RangeOptions::default();
                    range_options.set_reverse(reverse);

                    let (range_begin, range_end) = range.into_parts();

                    let mut range_stream = tr.get_range(
                        KeySelector::first_greater_or_equal(range_begin),
                        KeySelector::first_greater_or_equal(range_end),
                        range_options,
                    );

                    for i in (0x00..=0x09).rev() {
                        // Safety: If `unwrap()` fails, then its a
                        //         bug.
                        let x = range_stream.next().await.unwrap();

                        let (key, value) = x?.into_parts();
                        assert_eq!(key, Key::from(Bytes::from(vec![i])));
                        assert_eq!(value, Value::from(Bytes::from(format!("value{}", i))));
                    }

                    Ok(())
                })
                .await?;

            Result::<(), Box<dyn Error>>::Ok(())
        }
    })?;

    Ok(())
}

fn subspace_start_end_forward() -> Result<(), Failed> {
    let rt = Builder::new_current_thread().build()?;

    let fdb_database_ref = unsafe { FDB_DATABASE.as_ref().unwrap() };

    rt.block_on({
        let fdb_database = fdb_database_ref.clone();
        async move {
            fdb_database
                .read(|tr| async move {
                    let maybe_subspace = Some(Subspace::new(Bytes::from_static(b"subspace")));
                    let key_range = KeyRange::new(KeyLowEndpoint::Start, KeyHighEndpoint::End);
                    let continuation = None;
                    let reverse = false;

                    let range = key_value_cursor_builder_build_range(
                        &maybe_subspace,
                        key_range,
                        continuation,
                        reverse,
                    )?;

                    let (range_begin, range_end) = range.clone().into_parts();
                    assert_eq!(range_begin, Key::from(Bytes::from_static(b"subspace")));
                    // First key that does not have "subspace" as its
                    // prefix.
                    //
                    // The reference key is "subspacf". The
                    // intermediate resolved key is going to be
                    // "subspace\x09". Because offset is 1, the final
                    // resolved key would be "\xfd"
                    //
                    // The end key selector would be exclusive,
                    // effectively the range would end up begin
                    // `["subspace", "\xFD")`.
                    assert_eq!(range_end, Key::from(Bytes::from_static(b"subspacf")));

                    let mut range_options = RangeOptions::default();
                    range_options.set_reverse(reverse);

                    let (range_begin, range_end) = range.into_parts();

                    let mut range_stream = tr.get_range(
                        KeySelector::first_greater_or_equal(range_begin),
                        KeySelector::first_greater_or_equal(range_end),
                        range_options,
                    );

                    {
                        // Safety: If `unwrap()` fails, then its a
                        //         bug.
                        let x = range_stream.next().await.unwrap();

                        let (key, value) = x?.into_parts();
                        assert_eq!(key, Key::from(Bytes::from_static(b"subspace")));
                        assert_eq!(value, Value::from(Bytes::from_static(b"subspace_value")));
                    }

                    for i in 0x00..=0x09 {
                        // Safety: If `unwrap()` fails, then its a
                        //         bug.
                        let x = range_stream.next().await.unwrap();

                        let (key, value) = x?.into_parts();
                        let assert_key = Key::from({
                            let mut b = BytesMut::new();
                            b.put(Bytes::from_static(b"subspace"));
                            b.put_u8(i);
                            Bytes::from(b)
                        });
                        assert_eq!(key, assert_key);
                        assert_eq!(
                            value,
                            Value::from(Bytes::from(format!("subspace_value{}", i)))
                        );
                    }

                    Ok(())
                })
                .await?;

            Result::<(), Box<dyn Error>>::Ok(())
        }
    })?;

    Ok(())
}

fn subspace_start_end_forward_begin_marker() -> Result<(), Failed> {
    let rt = Builder::new_current_thread().build()?;

    let fdb_database_ref = unsafe { FDB_DATABASE.as_ref().unwrap() };

    rt.block_on({
        let fdb_database = fdb_database_ref.clone();
        async move {
            fdb_database
                .read(|tr| async move {
                    let maybe_subspace = Some(Subspace::new(Bytes::from_static(b"subspace")));
                    let key_range = KeyRange::new(KeyLowEndpoint::Start, KeyHighEndpoint::End);
                    let continuation = Some(key_value_continuation_v0_begin_marker_bytes()?);
                    let reverse = false;

                    let range = key_value_cursor_builder_build_range(
                        &maybe_subspace,
                        key_range,
                        continuation,
                        reverse,
                    )?;

                    let (range_begin, range_end) = range.clone().into_parts();
                    assert_eq!(range_begin, Key::from(Bytes::from_static(b"subspace")));
                    // First key that does not have "subspace" as its
                    // prefix.
                    //
                    // The reference key is "subspacf". The
                    // intermediate resolved key is going to be
                    // "subspace\x09". Because offset is 1, the final
                    // resolved key would be "\xFD"
                    //
                    // The end key selector would be
                    // exclusive. Sffectively the range would end up
                    // being `["subspace", "\xFD")`.
                    assert_eq!(range_end, Key::from(Bytes::from_static(b"subspacf")));

                    let mut range_options = RangeOptions::default();
                    range_options.set_reverse(reverse);

                    let (range_begin, range_end) = range.into_parts();

                    let mut range_stream = tr.get_range(
                        KeySelector::first_greater_or_equal(range_begin),
                        KeySelector::first_greater_or_equal(range_end),
                        range_options,
                    );

                    {
                        // Safety: If `unwrap()` fails, then its a
                        //         bug.
                        let x = range_stream.next().await.unwrap();

                        let (key, value) = x?.into_parts();
                        assert_eq!(key, Key::from(Bytes::from_static(b"subspace")));
                        assert_eq!(value, Value::from(Bytes::from_static(b"subspace_value")));
                    }

                    for i in 0x00..=0x09 {
                        // Safety: If `unwrap()` fails, then its a
                        //         bug.
                        let x = range_stream.next().await.unwrap();

                        let (key, value) = x?.into_parts();
                        let assert_key = Key::from({
                            let mut b = BytesMut::new();
                            b.put(Bytes::from_static(b"subspace"));
                            b.put_u8(i);
                            Bytes::from(b)
                        });
                        assert_eq!(key, assert_key);
                        assert_eq!(
                            value,
                            Value::from(Bytes::from(format!("subspace_value{}", i)))
                        );
                    }

                    Ok(())
                })
                .await?;

            Result::<(), Box<dyn Error>>::Ok(())
        }
    })?;

    Ok(())
}

fn subspace_start_end_reverse() -> Result<(), Failed> {
    let rt = Builder::new_current_thread().build()?;

    let fdb_database_ref = unsafe { FDB_DATABASE.as_ref().unwrap() };

    rt.block_on({
        let fdb_database = fdb_database_ref.clone();
        async move {
            fdb_database
                .read(|tr| async move {
                    let maybe_subspace = Some(Subspace::new(Bytes::from_static(b"subspace")));
                    let key_range = KeyRange::new(KeyLowEndpoint::Start, KeyHighEndpoint::End);
                    let continuation = None;
                    let reverse = true;

                    let range = key_value_cursor_builder_build_range(
                        &maybe_subspace,
                        key_range,
                        continuation,
                        reverse,
                    )?;

                    let (range_begin, range_end) = range.clone().into_parts();
                    assert_eq!(range_begin, Key::from(Bytes::from_static(b"subspace")));
                    // First key that does not have "subspace" as its
                    // prefix.
                    //
                    // The reference key is "subspacf". The
                    // intermediate resolved key is going to be
                    // "subspace\x09". Because offset is 1, the final
                    // resolved key would be "\xFD"
                    //
                    // The end key selector would be exclusive,
                    // effectively the range would end up begin
                    // `["subspace", "\xFD")`.
                    assert_eq!(range_end, Key::from(Bytes::from_static(b"subspacf")));

                    let mut range_options = RangeOptions::default();
                    range_options.set_reverse(reverse);

                    let (range_begin, range_end) = range.into_parts();

                    let mut range_stream = tr.get_range(
                        KeySelector::first_greater_or_equal(range_begin),
                        KeySelector::first_greater_or_equal(range_end),
                        range_options,
                    );

                    for i in (0x00..=0x09).rev() {
                        // Safety: If `unwrap()` fails, then its a
                        //         bug.
                        let x = range_stream.next().await.unwrap();

                        let (key, value) = x?.into_parts();
                        let assert_key = Key::from({
                            let mut b = BytesMut::new();
                            b.put(Bytes::from_static(b"subspace"));
                            b.put_u8(i);
                            Bytes::from(b)
                        });
                        assert_eq!(key, assert_key);
                        assert_eq!(
                            value,
                            Value::from(Bytes::from(format!("subspace_value{}", i)))
                        );
                    }

                    {
                        // Safety: If `unwrap()` fails, then its a
                        //         bug.
                        let x = range_stream.next().await.unwrap();

                        let (key, value) = x?.into_parts();
                        assert_eq!(key, Key::from(Bytes::from_static(b"subspace")));
                        assert_eq!(value, Value::from(Bytes::from_static(b"subspace_value")));
                    }

                    Ok(())
                })
                .await?;

            Result::<(), Box<dyn Error>>::Ok(())
        }
    })?;

    Ok(())
}

fn subspace_start_end_reverse_begin_marker() -> Result<(), Failed> {
    let rt = Builder::new_current_thread().build()?;

    let fdb_database_ref = unsafe { FDB_DATABASE.as_ref().unwrap() };

    rt.block_on({
        let fdb_database = fdb_database_ref.clone();
        async move {
            fdb_database
                .read(|tr| async move {
                    let maybe_subspace = Some(Subspace::new(Bytes::from_static(b"subspace")));
                    let key_range = KeyRange::new(KeyLowEndpoint::Start, KeyHighEndpoint::End);
                    let continuation = Some(key_value_continuation_v0_begin_marker_bytes()?);
                    let reverse = true;

                    let range = key_value_cursor_builder_build_range(
                        &maybe_subspace,
                        key_range,
                        continuation,
                        reverse,
                    )?;

                    let (range_begin, range_end) = range.clone().into_parts();
                    assert_eq!(range_begin, Key::from(Bytes::from_static(b"subspace")));
                    // First key that does not have "subspace" as its
                    // prefix.
                    //
                    // The reference key is "subspacf". The
                    // intermediate resolved key is going to be
                    // "subspace\x09". Because offset is 1, the final
                    // resolved key would be "\xFD"
                    //
                    // The end key selector would be exclusive,
                    // effectively the range would end up being
                    // `["subspace", "\xFD")`.
                    assert_eq!(range_end, Key::from(Bytes::from_static(b"subspacf")));

                    let mut range_options = RangeOptions::default();
                    range_options.set_reverse(reverse);

                    let (range_begin, range_end) = range.into_parts();

                    let mut range_stream = tr.get_range(
                        KeySelector::first_greater_or_equal(range_begin),
                        KeySelector::first_greater_or_equal(range_end),
                        range_options,
                    );

                    for i in (0x00..=0x09).rev() {
                        // Safety: If `unwrap()` fails, then its a
                        //         bug.
                        let x = range_stream.next().await.unwrap();

                        let (key, value) = x?.into_parts();
                        let assert_key = Key::from({
                            let mut b = BytesMut::new();
                            b.put(Bytes::from_static(b"subspace"));
                            b.put_u8(i);
                            Bytes::from(b)
                        });
                        assert_eq!(key, assert_key);
                        assert_eq!(
                            value,
                            Value::from(Bytes::from(format!("subspace_value{}", i)))
                        );
                    }

                    {
                        // Safety: If `unwrap()` fails, then its a
                        //         bug.
                        let x = range_stream.next().await.unwrap();

                        let (key, value) = x?.into_parts();
                        assert_eq!(key, Key::from(Bytes::from_static(b"subspace")));
                        assert_eq!(value, Value::from(Bytes::from_static(b"subspace_value")));
                    }

                    Ok(())
                })
                .await?;

            Result::<(), Box<dyn Error>>::Ok(())
        }
    })?;

    Ok(())
}