opendal 0.1.6.pre.rc.1

data/core/benches/ops/write.rs

@@ -0,0 +1,106 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+use divan::counter::BytesCount;
+use divan::Bencher;
+use opendal::raw::tests::init_test_service;
+use opendal::raw::tests::TEST_RUNTIME;
+use rand::prelude::*;
+use size::Size;
+
+use super::utils::*;
+
+#[divan::bench(
+    args = [
+        Size::from_kib(4),
+        Size::from_kib(64),
+        Size::from_mib(1),
+        Size::from_mib(16),
+    ],
+    ignore = std::env::var("OPENDAL_TEST").is_err()
+)]
+fn whole(b: Bencher, size: Size) {
+    let op = init_test_service().unwrap().unwrap();
+    let path = uuid::Uuid::new_v4().to_string();
+    let _temp_data = TempData::existing(op.clone(), &path);
+
+    b.counter(BytesCount::from(size.bytes() as u64))
+        .with_inputs(|| {
+            let mut rng = thread_rng();
+            gen_bytes(&mut rng, size.bytes() as usize)
+        })
+        .bench_values(|content| {
+            let op = op.clone();
+            let path = path.clone();
+            TEST_RUNTIME.block_on(async move {
+                let _ = op.write(&path, content).await.unwrap();
+            })
+        })
+}
+
+mod concurrent {
+    use super::*;
+
+    /// Size of the data to be written.
+    const SIZE: usize = 64 * 1024 * 1024;
+
+    #[divan::bench(
+        ignore = std::env::var("OPENDAL_TEST").is_err()
+    )]
+    fn baseline(b: Bencher) {
+        let op = init_test_service().unwrap().unwrap();
+        let path = uuid::Uuid::new_v4().to_string();
+        let _temp_data = TempData::existing(op.clone(), &path);
+        let mut rng = thread_rng();
+        let content = gen_bytes(&mut rng, SIZE);
+
+        b.counter(BytesCount::from(SIZE)).bench(|| {
+            let op = op.clone();
+            let path = path.clone();
+            let content = content.clone();
+            TEST_RUNTIME.block_on(async move {
+                let _ = op.write(&path, content).await.unwrap();
+            })
+        })
+    }
+
+    #[divan::bench(
+        args = [1, 2, 4, 8],
+        ignore = std::env::var("OPENDAL_TEST").is_err()
+    )]
+    fn concurrent(b: Bencher, concurrent: usize) {
+        let op = init_test_service().unwrap().unwrap();
+        let path = uuid::Uuid::new_v4().to_string();
+        let _temp_data = TempData::existing(op.clone(), &path);
+        let mut rng = thread_rng();
+        let content = gen_bytes(&mut rng, SIZE);
+
+        b.counter(BytesCount::from(SIZE)).bench(|| {
+            let op = op.clone();
+            let path = path.clone();
+            let content = content.clone();
+            TEST_RUNTIME.block_on(async move {
+                let _ = op
+                    .write_with(&path, content)
+                    .chunk(8 * 1024 * 1024)
+                    .concurrent(concurrent)
+                    .await
+                    .unwrap();
+            })
+        })
+    }
+}

data/core/benches/types/README.md

@@ -0,0 +1,9 @@
+# Types Benchmark Tests
+
+This benchmark contains performance testing of critical data structures in opendal types, currently including performance testing of Buffer.
+
+## Run
+
+```shell
+cargo bench types --features tests
+```

data/core/benches/types/buffer.rs

@@ -0,0 +1,114 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+use bytes::Buf;
+use bytes::Bytes;
+use divan::black_box;
+use divan::Bencher;
+use opendal::Buffer;
+
+mod chunk {
+    use super::*;
+
+    #[divan::bench]
+    fn bytes(b: Bencher) {
+        b.with_inputs(|| Bytes::from(vec![1; 10]))
+            .bench_refs(|buffer| {
+                black_box(buffer.chunk());
+            });
+    }
+
+    #[divan::bench]
+    fn contiguous(b: Bencher) {
+        b.with_inputs(|| Buffer::from(vec![1; 10]))
+            .bench_refs(|buffer| {
+                black_box(buffer.chunk());
+            });
+    }
+
+    #[divan::bench(args = [10, 1_000, 1_000_000])]
+    fn non_contiguous(b: Bencher, parts: usize) {
+        b.with_inputs(|| Buffer::from([1; 1].repeat(parts)))
+            .bench_refs(|buffer| {
+                black_box(buffer.chunk());
+            });
+    }
+}
+
+mod advance {
+    use super::*;
+
+    #[divan::bench]
+    fn bytes(b: Bencher) {
+        b.with_inputs(|| Bytes::from(vec![1; 10]))
+            .bench_refs(|buffer| buffer.advance(4));
+    }
+
+    #[divan::bench]
+    fn contiguous(b: Bencher) {
+        b.with_inputs(|| Buffer::from(vec![1; 10]))
+            .bench_refs(|buffer| buffer.advance(4));
+    }
+
+    #[divan::bench(args = [10, 1_000, 1_000_000])]
+    fn non_contiguous(b: Bencher, parts: usize) {
+        b.with_inputs(|| Buffer::from([1; 1].repeat(parts)))
+            .bench_refs(|buffer| buffer.advance(4));
+    }
+}
+
+mod truncate {
+    use super::*;
+
+    #[divan::bench]
+    fn bytes(b: Bencher) {
+        b.with_inputs(|| Bytes::from(vec![1; 10]))
+            .bench_refs(|buffer| buffer.truncate(5));
+    }
+
+    #[divan::bench]
+    fn contiguous(b: Bencher) {
+        b.with_inputs(|| Buffer::from(vec![1; 10]))
+            .bench_refs(|buffer| buffer.truncate(5));
+    }
+
+    #[divan::bench(args = [10, 1_000, 1_000_000])]
+    fn non_contiguous(b: Bencher, parts: usize) {
+        b.with_inputs(|| Buffer::from([1; 1].repeat(parts)))
+            .bench_refs(|buffer| buffer.truncate(4));
+    }
+}
+
+mod iterator {
+    use super::*;
+
+    #[divan::bench]
+    fn contiguous(b: Bencher) {
+        b.with_inputs(|| Buffer::from(vec![1; 1_000_000]))
+            .bench_refs(|buffer| loop {
+                let Some(_) = buffer.next() else { break };
+            });
+    }
+
+    #[divan::bench(args = [10, 1_000, 1_000_000])]
+    fn non_contiguous(b: Bencher, parts: usize) {
+        b.with_inputs(|| Buffer::from(vec![1; 1_000_000 / parts].repeat(parts)))
+            .bench_refs(|buffer| loop {
+                let Some(_) = buffer.next() else { break };
+            });
+    }
+}

data/core/benches/types/main.rs

@@ -0,0 +1,23 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+mod buffer;
+mod tasks;
+
+fn main() {
+    divan::main();
+}

data/core/benches/types/tasks.rs

@@ -0,0 +1,64 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+use std::sync::LazyLock;
+use std::time::Duration;
+
+use divan::Bencher;
+use opendal::raw::ConcurrentTasks;
+use opendal::Executor;
+
+pub static TOKIO: LazyLock<tokio::runtime::Runtime> =
+    LazyLock::new(|| tokio::runtime::Runtime::new().expect("build tokio runtime"));
+
+pub static TOTAL_TASKS: usize = 128;
+
+#[divan::bench]
+fn baseline(b: Bencher) {
+    b.bench(|| {
+        TOKIO.block_on(async move {
+            for _ in 0..TOTAL_TASKS {
+                tokio::time::sleep(Duration::from_millis(1)).await;
+            }
+        })
+    });
+}
+
+#[divan::bench(args = [1, 2, 8, 32])]
+fn concurrent(b: Bencher, concurrent: usize) {
+    b.with_inputs(|| {
+        ConcurrentTasks::new(Executor::new(), concurrent, 8, |()| {
+            Box::pin(async {
+                tokio::time::sleep(Duration::from_millis(1)).await;
+                ((), Ok(()))
+            })
+        })
+    })
+    .bench_refs(|tasks| {
+        TOKIO.block_on(async move {
+            for _ in 0..TOTAL_TASKS {
+                let _ = tasks.execute(()).await;
+            }
+
+            loop {
+                if tasks.next().await.is_none() {
+                    break;
+                }
+            }
+        })
+    });
+}

data/core/benches/vs_fs/Cargo.toml

@@ -0,0 +1,32 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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]
+description = "OpenDAL Benchmark vs fs"
+edition = "2021"
+license = "Apache-2.0"
+name = "opendal-benchmark-vs-fs"
+publish = false
+rust-version = "1.82"
+version = "0.0.0"
+
+[dependencies]
+criterion = { version = "0.7", features = ["async", "async_tokio"] }
+opendal = { path = "../..", features = ["tests"] }
+rand = "0.8"
+tokio = { version = "1", features = ["full"] }
+uuid = { version = "1", features = ["v4"] }

data/core/benches/vs_fs/README.md

@@ -0,0 +1,35 @@
+# OpenDAL Benchmark VS Fs
+
+This benchmark compares the performance of OpenDAL with the performance of the `std::fs`.
+
+## Goal
+
+We expect OpenDAL to match `std::fs` in speed: the throughput of OpenDAL should be within a `5%` range of `std::fs`.
+
+## Usage
+
+For test: `cargo run`
+
+```shell
+Testing vs_fs/std_fs_read
+Success
+Testing vs_fs/opendal_fs_read
+Success
+Testing vs_fs/opendal_fs_read_with_range
+Success
+```
+
+For bench: `cargo run --release -- --bench`
+
+```shell
+read/std_fs       time:   [749.57 µs 762.69 µs 777.07 µs]
+                  thrpt:  [20.108 GiB/s 20.487 GiB/s 20.845 GiB/s]
+                        
+read/opendal_fs   time:   [750.90 µs 755.39 µs 760.49 µs]
+                  thrpt:  [20.546 GiB/s 20.685 GiB/s 20.808 GiB/s]
+                        
+read/opendal_fs_with_range
+                  time:   [684.02 µs 690.77 µs 697.99 µs]
+                  thrpt:  [22.386 GiB/s 22.620 GiB/s 22.843 GiB/s]
+
+```

data/core/benches/vs_fs/src/main.rs

@@ -0,0 +1,83 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+use criterion::Criterion;
+use opendal::blocking;
+use opendal::options;
+use opendal::services;
+use opendal::Operator;
+use rand::prelude::*;
+
+fn main() {
+    let mut c = Criterion::default().configure_from_args();
+    bench_vs_fs(&mut c);
+
+    c.final_summary();
+}
+
+fn bench_vs_fs(c: &mut Criterion) {
+    let cfg = services::Fs::default().root("/tmp/opendal/");
+    let op = Operator::new(cfg).unwrap().finish();
+
+    let runtime = tokio::runtime::Runtime::new().unwrap();
+    let _guard = runtime.enter();
+    let op = blocking::Operator::new(op).unwrap();
+
+    let mut group = c.benchmark_group("read");
+    group.throughput(criterion::Throughput::Bytes(16 * 1024 * 1024));
+
+    group.bench_function("std_fs", |b| {
+        let path = format!("/tmp/opendal/{}", prepare());
+        b.iter(|| {
+            let _ = std::fs::read(&path).unwrap();
+        });
+    });
+    group.bench_function("opendal_fs", |b| {
+        let path = prepare();
+        b.iter(|| {
+            let _ = op.read(&path).unwrap();
+        });
+    });
+    group.bench_function("opendal_fs_with_range", |b| {
+        let path = prepare();
+        b.iter(|| {
+            let _ = op
+                .read_options(
+                    &path,
+                    options::ReadOptions {
+                        range: (0..16 * 1024 * 1024).into(),
+                        ..Default::default()
+                    },
+                )
+                .unwrap();
+        });
+    });
+
+    group.finish()
+}
+
+fn prepare() -> String {
+    let mut rng = thread_rng();
+    let mut content = vec![0; 16 * 1024 * 1024];
+    rng.fill_bytes(&mut content);
+
+    let name = uuid::Uuid::new_v4();
+    let path = format!("/tmp/opendal/{name}");
+    let _ = std::fs::write(path, content);
+
+    name.to_string()
+}

data/core/benches/vs_s3/Cargo.toml

@@ -0,0 +1,38 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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]
+description = "OpenDAL Benchmark vs s3"
+edition = "2021"
+license = "Apache-2.0"
+name = "opendal-benchmark-vs-s3"
+publish = false
+rust-version = "1.82"
+version = "0.0.0"
+
+[dependencies]
+aws-config = { version = "1.0.1", features = ["behavior-version-latest"] }
+aws-credential-types = { version = "1.2.4", features = [
+  "hardcoded-credentials",
+] }
+aws-sdk-s3 = "1.91.0"
+criterion = { version = "0.7", features = ["async", "async_tokio"] }
+dotenvy = "0.15"
+logforth = { version = "0.23.1", default-features = false }
+opendal = { path = "../..", features = ["tests"] }
+rand = "0.8"
+tokio = { version = "1", features = ["full"] }

data/core/benches/vs_s3/README.md

@@ -0,0 +1,55 @@
+# OpenDAL Benchmark VS AWS SDK S3
+
+This benchmark compares the performance of OpenDAL with the performance of the `aws_sdk_s3`.
+
+## Goal
+
+We expect OpenDAL to match `aws_sdk_s3` in speed: the throughput of OpenDAL should be within a `5%` range of `aws_sdk_s3`.
+
+## Notes
+
+Please run bench case separately, otherwise the result will be affected by each other since we are sharing the same runtime.
+
+## Usage
+
+For test: `cargo run`
+
+```shell
+> cargo run
+Testing read/opendal_s3_reader
+Success
+Testing read/aws_s3_sdk_into_async_read
+Success
+Testing read/opendal_s3_reader_with_capacity
+Success
+Testing read/aws_s3_sdk_into_async_read_with_capacity
+Success
+```
+
+For bench case: `cargo run --release -- opendal_s3_reader --bench`
+
+```shell
+> cargo run --release -- opendal_s3_reader --bench
+read/opendal_s3_reader  time:   [12.773 ms 13.004 ms 13.232 ms]
+                        thrpt:  [1.1809 GiB/s 1.2016 GiB/s 1.2232 GiB/s]
+```
+
+For bench: `cargo run --release -- --bench`
+
+```shell
+> cargo run --release -- --bench
+read/opendal_s3_reader  time:   [12.773 ms 13.004 ms 13.232 ms]
+                        thrpt:  [1.1809 GiB/s 1.2016 GiB/s 1.2232 GiB/s]
+
+read/aws_s3_sdk_into_async_read
+                        time:   [12.527 ms 12.842 ms 13.158 ms]
+                        thrpt:  [1.1875 GiB/s 1.2168 GiB/s 1.2473 GiB/s]
+
+read/opendal_s3_reader_with_capacity
+                        time:   [9.6098 ms 9.8133 ms 10.017 ms]
+                        thrpt:  [1.5599 GiB/s 1.5922 GiB/s 1.6259 GiB/s]
+
+read/aws_s3_sdk_into_async_read_with_capacity
+                        time:   [9.8970 ms 10.113 ms 10.329 ms]
+                        thrpt:  [1.5128 GiB/s 1.5451 GiB/s 1.5788 GiB/s]
+```

data/core/benches/vs_s3/src/main.rs

@@ -0,0 +1,123 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+use std::env;
+
+use aws_config::BehaviorVersion;
+use aws_config::Region;
+use aws_credential_types::Credentials;
+use criterion::Criterion;
+use opendal::raw::tests::TEST_RUNTIME;
+use opendal::services;
+use opendal::Operator;
+use rand::prelude::*;
+use tokio::io::AsyncReadExt;
+
+fn main() {
+    let _ = dotenvy::dotenv();
+    let _ = logforth::stderr().try_apply();
+
+    let endpoint = env::var("OPENDAL_S3_ENDPOINT").unwrap();
+    let access_key = env::var("OPENDAL_S3_ACCESS_KEY_ID").unwrap();
+    let secret_key = env::var("OPENDAL_S3_SECRET_ACCESS_KEY").unwrap();
+    let bucket = env::var("OPENDAL_S3_BUCKET").unwrap();
+    let region = env::var("OPENDAL_S3_REGION").unwrap();
+
+    // Init OpenDAL Operator.
+    let cfg = services::S3::default()
+        .endpoint(&endpoint)
+        .access_key_id(&access_key)
+        .secret_access_key(&secret_key)
+        .bucket(&bucket)
+        .region(&region);
+    let op = Operator::new(cfg).unwrap().finish();
+
+    // Init AWS S3 SDK.
+    let mut config_loader = aws_config::defaults(BehaviorVersion::latest());
+    config_loader = config_loader.endpoint_url(&endpoint);
+    config_loader = config_loader.region(Region::new(region.to_string()));
+    config_loader =
+        config_loader.credentials_provider(Credentials::from_keys(&access_key, &secret_key, None));
+    let config = TEST_RUNTIME.block_on(config_loader.load());
+    let s3_client = aws_sdk_s3::Client::new(&config);
+
+    let mut c = Criterion::default().configure_from_args();
+    bench_read(&mut c, op, s3_client, &bucket);
+
+    c.final_summary();
+}
+
+fn bench_read(c: &mut Criterion, op: Operator, s3_client: aws_sdk_s3::Client, bucket: &str) {
+    let mut group = c.benchmark_group("read");
+    group.throughput(criterion::Throughput::Bytes(16 * 1024 * 1024));
+
+    TEST_RUNTIME.block_on(prepare(&op));
+
+    group.bench_function("opendal_s3_reader", |b| {
+        b.to_async(&*TEST_RUNTIME).iter(|| async {
+            let r = op.reader("file").await.unwrap();
+            let _ = r.read(..).await.unwrap();
+        });
+    });
+    group.bench_function("aws_s3_sdk_into_async_read", |b| {
+        b.to_async(&*TEST_RUNTIME).iter(|| async {
+            let mut r = s3_client
+                .get_object()
+                .bucket(bucket)
+                .key("file")
+                .send()
+                .await
+                .unwrap()
+                .body
+                .into_async_read();
+            let mut bs = Vec::new();
+            let _ = r.read_to_end(&mut bs).await.unwrap();
+        });
+    });
+
+    group.bench_function("opendal_s3_reader_with_capacity", |b| {
+        b.to_async(&*TEST_RUNTIME).iter(|| async {
+            let r = op.reader("file").await.unwrap();
+            let _ = r.read(..16 * 1024 * 1024).await.unwrap();
+        });
+    });
+    group.bench_function("aws_s3_sdk_into_async_read_with_capacity", |b| {
+        b.to_async(&*TEST_RUNTIME).iter(|| async {
+            let mut r = s3_client
+                .get_object()
+                .bucket(bucket)
+                .key("file")
+                .send()
+                .await
+                .unwrap()
+                .body
+                .into_async_read();
+            let mut bs = Vec::with_capacity(16 * 1024 * 1024);
+            let _ = r.read_to_end(&mut bs).await.unwrap();
+        });
+    });
+
+    group.finish()
+}
+
+async fn prepare(op: &Operator) {
+    let mut rng = thread_rng();
+    let mut content = vec![0; 16 * 1024 * 1024];
+    rng.fill_bytes(&mut content);
+
+    op.write("file", content).await.unwrap();
+}

data/core/edge/README.md

@@ -0,0 +1,3 @@
+# OpenDAL Edge Tests
+
+OpenDAL edge tests served as edge tests for the OpenDAL project. They will have pre-set data and will test the functionality of the OpenDAL project.