Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 328 insertions, 0 deletions

diff --git a/third_party/rust/rkv/tests/env-all.rs b/third_party/rust/rkv/tests/env-all.rs
new file mode 100644
index 0000000000..a8d93c786e
--- /dev/null
+++ b/third_party/rust/rkv/tests/env-all.rs
@@ -0,0 +1,328 @@
+// Copyright 2018-2019 Mozilla
+//
+// 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.
+
+use std::fs;
+
+use tempfile::Builder;
+
+use rkv::{
+    backend::{Lmdb, SafeMode},
+    Rkv, StoreOptions, Value,
+};
+
+#[test]
+fn test_open_safe_same_dir_as_lmdb() {
+    let root = Builder::new()
+        .prefix("test_open_safe_same_dir_as_lmdb")
+        .tempdir()
+        .expect("tempdir");
+    fs::create_dir_all(root.path()).expect("dir created");
+
+    // Create database of type A and save to disk.
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::create()).expect("opened");
+
+        let mut writer = k.write().expect("writer");
+        sk.put(&mut writer, "foo", &Value::I64(1234))
+            .expect("wrote");
+        sk.put(&mut writer, "bar", &Value::Bool(true))
+            .expect("wrote");
+        sk.put(&mut writer, "baz", &Value::Str("héllo, yöu"))
+            .expect("wrote");
+        assert_eq!(
+            sk.get(&writer, "foo").expect("read"),
+            Some(Value::I64(1234))
+        );
+        assert_eq!(
+            sk.get(&writer, "bar").expect("read"),
+            Some(Value::Bool(true))
+        );
+        assert_eq!(
+            sk.get(&writer, "baz").expect("read"),
+            Some(Value::Str("héllo, yöu"))
+        );
+        writer.commit().expect("committed");
+        k.sync(true).expect("synced");
+    }
+    // Verify that database of type A was written to disk.
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let sk = k
+            .open_single("sk", StoreOptions::default())
+            .expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(
+            sk.get(&reader, "foo").expect("read"),
+            Some(Value::I64(1234))
+        );
+        assert_eq!(
+            sk.get(&reader, "bar").expect("read"),
+            Some(Value::Bool(true))
+        );
+        assert_eq!(
+            sk.get(&reader, "baz").expect("read"),
+            Some(Value::Str("héllo, yöu"))
+        );
+    }
+    // Create database of type B and verify that it is empty.
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let _ = k
+            .open_single("sk", StoreOptions::default())
+            .expect_err("not opened");
+    }
+    // Verify that database of type A wasn't changed.
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let sk = k
+            .open_single("sk", StoreOptions::default())
+            .expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(
+            sk.get(&reader, "foo").expect("read"),
+            Some(Value::I64(1234))
+        );
+        assert_eq!(
+            sk.get(&reader, "bar").expect("read"),
+            Some(Value::Bool(true))
+        );
+        assert_eq!(
+            sk.get(&reader, "baz").expect("read"),
+            Some(Value::Str("héllo, yöu"))
+        );
+    }
+    // Create database of type B and save to disk (type A exists at the same path).
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::create()).expect("opened");
+
+        let mut writer = k.write().expect("writer");
+        sk.put(&mut writer, "foo1", &Value::I64(5678))
+            .expect("wrote");
+        sk.put(&mut writer, "bar1", &Value::Bool(false))
+            .expect("wrote");
+        sk.put(&mut writer, "baz1", &Value::Str("héllo~ yöu"))
+            .expect("wrote");
+        assert_eq!(
+            sk.get(&writer, "foo1").expect("read"),
+            Some(Value::I64(5678))
+        );
+        assert_eq!(
+            sk.get(&writer, "bar1").expect("read"),
+            Some(Value::Bool(false))
+        );
+        assert_eq!(
+            sk.get(&writer, "baz1").expect("read"),
+            Some(Value::Str("héllo~ yöu"))
+        );
+        writer.commit().expect("committed");
+        k.sync(true).expect("synced");
+    }
+    // Verify that database of type B was written to disk.
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let sk = k
+            .open_single("sk", StoreOptions::default())
+            .expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(
+            sk.get(&reader, "foo1").expect("read"),
+            Some(Value::I64(5678))
+        );
+        assert_eq!(
+            sk.get(&reader, "bar1").expect("read"),
+            Some(Value::Bool(false))
+        );
+        assert_eq!(
+            sk.get(&reader, "baz1").expect("read"),
+            Some(Value::Str("héllo~ yöu"))
+        );
+    }
+    // Verify that database of type A still wasn't changed.
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let sk = k
+            .open_single("sk", StoreOptions::default())
+            .expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(
+            sk.get(&reader, "foo").expect("read"),
+            Some(Value::I64(1234))
+        );
+        assert_eq!(
+            sk.get(&reader, "bar").expect("read"),
+            Some(Value::Bool(true))
+        );
+        assert_eq!(
+            sk.get(&reader, "baz").expect("read"),
+            Some(Value::Str("héllo, yöu"))
+        );
+    }
+}
+
+#[test]
+fn test_open_lmdb_same_dir_as_safe() {
+    let root = Builder::new()
+        .prefix("test_open_lmdb_same_dir_as_safe")
+        .tempdir()
+        .expect("tempdir");
+    fs::create_dir_all(root.path()).expect("dir created");
+
+    // Create database of type A and save to disk.
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::create()).expect("opened");
+
+        let mut writer = k.write().expect("writer");
+        sk.put(&mut writer, "foo", &Value::I64(1234))
+            .expect("wrote");
+        sk.put(&mut writer, "bar", &Value::Bool(true))
+            .expect("wrote");
+        sk.put(&mut writer, "baz", &Value::Str("héllo, yöu"))
+            .expect("wrote");
+        assert_eq!(
+            sk.get(&writer, "foo").expect("read"),
+            Some(Value::I64(1234))
+        );
+        assert_eq!(
+            sk.get(&writer, "bar").expect("read"),
+            Some(Value::Bool(true))
+        );
+        assert_eq!(
+            sk.get(&writer, "baz").expect("read"),
+            Some(Value::Str("héllo, yöu"))
+        );
+        writer.commit().expect("committed");
+        k.sync(true).expect("synced");
+    }
+    // Verify that database of type A was written to disk.
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let sk = k
+            .open_single("sk", StoreOptions::default())
+            .expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(
+            sk.get(&reader, "foo").expect("read"),
+            Some(Value::I64(1234))
+        );
+        assert_eq!(
+            sk.get(&reader, "bar").expect("read"),
+            Some(Value::Bool(true))
+        );
+        assert_eq!(
+            sk.get(&reader, "baz").expect("read"),
+            Some(Value::Str("héllo, yöu"))
+        );
+    }
+    // Create database of type B and verify that it is empty.
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let _ = k
+            .open_single("sk", StoreOptions::default())
+            .expect_err("not opened");
+    }
+    // Verify that database of type A wasn't changed.
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let sk = k
+            .open_single("sk", StoreOptions::default())
+            .expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(
+            sk.get(&reader, "foo").expect("read"),
+            Some(Value::I64(1234))
+        );
+        assert_eq!(
+            sk.get(&reader, "bar").expect("read"),
+            Some(Value::Bool(true))
+        );
+        assert_eq!(
+            sk.get(&reader, "baz").expect("read"),
+            Some(Value::Str("héllo, yöu"))
+        );
+    }
+    // Create database of type B and save to disk (type A exists at the same path).
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let sk = k.open_single("sk", StoreOptions::create()).expect("opened");
+
+        let mut writer = k.write().expect("writer");
+        sk.put(&mut writer, "foo1", &Value::I64(5678))
+            .expect("wrote");
+        sk.put(&mut writer, "bar1", &Value::Bool(false))
+            .expect("wrote");
+        sk.put(&mut writer, "baz1", &Value::Str("héllo~ yöu"))
+            .expect("wrote");
+        assert_eq!(
+            sk.get(&writer, "foo1").expect("read"),
+            Some(Value::I64(5678))
+        );
+        assert_eq!(
+            sk.get(&writer, "bar1").expect("read"),
+            Some(Value::Bool(false))
+        );
+        assert_eq!(
+            sk.get(&writer, "baz1").expect("read"),
+            Some(Value::Str("héllo~ yöu"))
+        );
+        writer.commit().expect("committed");
+        k.sync(true).expect("synced");
+    }
+    // Verify that database of type B was written to disk.
+    {
+        let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
+        let sk = k
+            .open_single("sk", StoreOptions::default())
+            .expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(
+            sk.get(&reader, "foo1").expect("read"),
+            Some(Value::I64(5678))
+        );
+        assert_eq!(
+            sk.get(&reader, "bar1").expect("read"),
+            Some(Value::Bool(false))
+        );
+        assert_eq!(
+            sk.get(&reader, "baz1").expect("read"),
+            Some(Value::Str("héllo~ yöu"))
+        );
+    }
+    // Verify that database of type A still wasn't changed.
+    {
+        let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
+        let sk = k
+            .open_single("sk", StoreOptions::default())
+            .expect("opened");
+
+        let reader = k.read().expect("reader");
+        assert_eq!(
+            sk.get(&reader, "foo").expect("read"),
+            Some(Value::I64(1234))
+        );
+        assert_eq!(
+            sk.get(&reader, "bar").expect("read"),
+            Some(Value::Bool(true))
+        );
+        assert_eq!(
+            sk.get(&reader, "baz").expect("read"),
+            Some(Value::Str("héllo, yöu"))
+        );
+    }
+}