Unit test passing locally

Author: Nao-ris

Cargo.toml

@@ -2,6 +2,7 @@
 name = "couchbase_lite"
 version = "3.1.10-0"
 # The first three numbers correspond to the Couchbase Lite C release, the fourth number corresponds to the Doctolib release
+edition = "2021"
 
 [dependencies]
 enum_primitive = "*"

src/blob.rs

@@ -160,14 +160,14 @@ pub struct BlobReader<'r> {
     stream_ref: *mut CBLBlobReadStream,
 }
 
-impl<'r> CblRef for BlobReader<'r> {
+impl CblRef for BlobReader<'_> {
     type Output = *mut CBLBlobReadStream;
     fn get_ref(&self) -> Self::Output {
         self.stream_ref
     }
 }
 
-impl<'r> std::io::Read for BlobReader<'r> {
+impl std::io::Read for BlobReader<'_> {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         unsafe {
             check_io(|err| {
@@ -182,7 +182,7 @@ impl<'r> std::io::Read for BlobReader<'r> {
     }
 }
 
-impl<'r> Drop for BlobReader<'r> {
+impl Drop for BlobReader<'_> {
     fn drop(&mut self) {
         unsafe {
             CBLBlobReader_Close(self.get_ref());
@@ -200,7 +200,7 @@ pub struct BlobWriter<'d> {
     db: PhantomData<&'d mut Database>,
 }
 
-impl<'d> CblRef for BlobWriter<'d> {
+impl CblRef for BlobWriter<'_> {
     type Output = *mut CBLBlobWriteStream;
     fn get_ref(&self) -> Self::Output {
         self.stream_ref
@@ -222,7 +222,7 @@ impl<'d> BlobWriter<'d> {
     }
 }
 
-impl<'r> std::io::Write for BlobWriter<'r> {
+impl std::io::Write for BlobWriter<'_> {
     fn write(&mut self, data: &[u8]) -> std::result::Result<usize, std::io::Error> {
         unsafe {
             check_io(|err| {
@@ -246,7 +246,7 @@ impl<'r> std::io::Write for BlobWriter<'r> {
     }
 }
 
-impl<'r> Drop for BlobWriter<'r> {
+impl Drop for BlobWriter<'_> {
     fn drop(&mut self) {
         unsafe { CBLBlobWriter_Close(self.get_ref()) }
     }

src/fleece.rs

@@ -42,7 +42,7 @@ use std::fmt;
 use std::mem::MaybeUninit;
 use std::ptr;
 use std::str;
-use retain;
+use crate::retain;
 
 //////// CONTAINER
 

src/fleece_mutable.rs

@@ -442,14 +442,14 @@ pub struct Slot<'s> {
     owner: PhantomData<&'s mut MutableDict>,
 }
 
-impl<'s> CblRef for Slot<'s> {
+impl CblRef for Slot<'_> {
     type Output = FLSlot;
     fn get_ref(&self) -> Self::Output {
         self.cbl_ref
     }
 }
 
-impl<'s> Slot<'s> {
+impl Slot<'_> {
     pub fn put_null(self) {
         unsafe { FLSlot_SetNull(self.get_ref()) }
     }

src/index.rs

@@ -7,11 +7,12 @@ use crate::{
         CBLQueryIndex, CBLQueryIndex_Name, CBLQueryIndex_Collection, CBLCollection_GetIndex,
     },
     error::{Result, failure},
-    slice::from_str,
+    slice::{from_str, from_c_str},
     QueryLanguage, Array,
     collection::Collection,
     check_error, retain,
 };
+use std::ffi::CString;
 
 pub struct ValueIndexConfiguration {
     cbl_ref: CBLValueIndexConfiguration,
@@ -40,8 +41,11 @@ impl ValueIndexConfiguration {
     }
 }
 
+#[derive(Debug)]
 pub struct ArrayIndexConfiguration {
     cbl_ref: CBLArrayIndexConfiguration,
+    _path: CString,
+    _expressions: CString,
 }
 
 impl CblRef for ArrayIndexConfiguration {
@@ -64,14 +68,17 @@ impl ArrayIndexConfiguration {
         using comma delimiter. If the array specified by the path contains scalar values,
         the expressions should be left unset or set to null. */
     pub fn new(query_language: QueryLanguage, path: &str, expressions: &str) -> Self {
-        let s_path = from_str(path);
-        let s_expressions = from_str(expressions);
+        let path_c = CString::new(path).unwrap();
+        let expressions_c = CString::new(expressions).unwrap();
+
         Self {
             cbl_ref: CBLArrayIndexConfiguration {
                 expressionLanguage: query_language as u32,
-                path: s_path.get_ref(),
-                expressions: s_expressions.get_ref(),
+                path: from_c_str(&path_c, path.len()).get_ref(),
+                expressions: from_c_str(&expressions_c, expressions.len()).get_ref(),
             },
+            _path: path_c,
+            _expressions: expressions_c,
         }
     }
 }

src/query.rs

@@ -30,8 +30,8 @@ use crate::{
     Listener,
 };
 
-use std::{os::raw::c_uint};
-use ListenerToken;
+use std::os::raw::c_uint;
+use crate::ListenerToken;
 
 /** Query languages. */
 pub enum QueryLanguage {

src/slice.rs

@@ -98,6 +98,16 @@ pub fn from_str(s: &str) -> Slice<&str> {
     )
 }
 
+pub fn from_c_str(s: &CStr, len: usize) -> Slice<&CStr> {
+    Slice::wrap(
+        FLSlice {
+            buf: s.as_ptr().cast::<c_void>(),
+            size: len,
+        },
+        s,
+    )
+}
+
 pub fn from_bytes(s: &[u8]) -> Slice<&[u8]> {
     Slice::wrap(
         FLSlice {
@@ -114,7 +124,7 @@ impl FLSlice {
         if !self {
             return None;
         }
-        return Some(std::slice::from_raw_parts(self.buf.cast::<u8>(), self.size));
+        Some(std::slice::from_raw_parts(self.buf.cast::<u8>(), self.size))
     }
 
     pub(crate) unsafe fn as_str<'a>(&self) -> Option<&'a str> {

tests/query_tests.rs

@@ -284,9 +284,10 @@ fn array_index() {
         // Index with one level of unnest
         let index_configuration = ArrayIndexConfiguration::new(QueryLanguage::N1QL, "likes", "");
 
-        assert!(default_collection
-            .create_array_index("one_level", &index_configuration,)
-            .unwrap());
+        let result = default_collection
+            .create_array_index("one_level", &index_configuration)
+            .unwrap();
+        assert!(result);
 
         let query = Query::new(
             db,
@@ -305,18 +306,12 @@ fn array_index() {
         assert!(result.next().is_none());
 
         // Index with two levels of unnest
-        /*let index_configuration = ArrayIndexConfiguration::new(
-            QueryLanguage::N1QL,
-            "contacts[].phones",
-            "",//"type",
-        );
+        let index_configuration =
+            ArrayIndexConfiguration::new(QueryLanguage::N1QL, "contacts[].phones", "type");
 
         assert!(default_collection
-            .create_array_index(
-                "myindex",
-                &index_configuration,
-            ).unwrap()
-        );
+            .create_array_index("two_levels", &index_configuration,)
+            .unwrap());
 
         let query = Query::new(
             db,
@@ -325,18 +320,29 @@ fn array_index() {
                 FROM _
                 UNNEST _.contacts as contact
                 UNNEST contact.phones as phone
-                WHERE phone.type = 'mobile'"#
-        ).unwrap();
+                WHERE phone.type = 'mobile'"#,
+        )
+        .unwrap();
 
         println!("Explain: {}", query.explain().unwrap());
 
         let index = get_index_name_from_explain(&query.explain().unwrap()).unwrap();
         assert_eq!(index, "two_levels");
 
         let mut result = query.execute().unwrap();
+
         let row = result.next().unwrap();
-        assert_eq!(row.as_array().to_json(), r#"["Sam","travel"]"#);
+        assert_eq!(
+            row.as_array().to_json(),
+            r#"["Sam","primary","310-123-6789"]"#
+        );
 
-        assert!(result.next().is_none());*/
+        let row = result.next().unwrap();
+        assert_eq!(
+            row.as_array().to_json(),
+            r#"["Sam","secondary","206-123-6789"]"#
+        );
+
+        assert!(result.next().is_none());
     })
 }