Skip to content
This repository was archived by the owner on Jun 8, 2021. It is now read-only.

Replace unwrap calls with expect in tests #593

Merged
merged 1 commit into from
Feb 13, 2020
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion glib-macros/src/genum_derive.rs
Original file line number Diff line number Diff line change
Expand Up @@ -261,7 +261,7 @@ pub fn impl_genum(input: &syn::DeriveInput) -> TokenStream {
},
];

let name = std::ffi::CString::new(#gtype_name).unwrap();
let name = std::ffi::CString::new(#gtype_name).expect("CString::new failed");
unsafe {
let type_ = gobject_sys::g_enum_register_static(name.as_ptr(), VALUES.as_ptr());
TYPE = glib::translate::from_glib(type_);
Expand Down
8 changes: 4 additions & 4 deletions glib-macros/tests/test.rs
Original file line number Diff line number Diff line change
Expand Up @@ -45,14 +45,14 @@ fn derive_genum() {
assert!(t.is_a(&glib::Type::BaseEnum));
assert_eq!(t.name(), "TestAnimalType");

let e = glib::EnumClass::new(t).unwrap();
let v = e.get_value(0).unwrap();
let e = glib::EnumClass::new(t).expect("EnumClass::new failed");
let v = e.get_value(0).expect("EnumClass::get_value(0) failed");
assert_eq!(v.get_name(), "Goat");
assert_eq!(v.get_nick(), "goat");
let v = e.get_value(1).unwrap();
let v = e.get_value(1).expect("EnumClass::get_value(1) failed");
assert_eq!(v.get_name(), "The Dog");
assert_eq!(v.get_nick(), "dog");
let v = e.get_value(5).unwrap();
let v = e.get_value(5).expect("EnumClass::get_value(5) failed");
assert_eq!(v.get_name(), "The Cat");
assert_eq!(v.get_nick(), "chat");
assert_eq!(e.get_value(2), None);
Expand Down
103 changes: 66 additions & 37 deletions src/subclass/object.rs
Original file line number Diff line number Diff line change
Expand Up @@ -434,14 +434,21 @@ mod test {
&[String::static_type()],
String::static_type(),
|_, args| {
let obj = args[0].get::<Object>().unwrap().unwrap();
let new_name = args[1].get::<String>().unwrap().unwrap();
let obj = args[0]
.get::<Object>()
.expect("Failed to get args[0]")
.expect("Failed to get Object from args[0]");
let new_name = args[1]
.get::<String>()
.expect("Failed to get args[1]")
.expect("Failed to get Object from args[1]");
let imp = Self::from_instance(&obj);

let old_name = imp.name.borrow_mut().take();
*imp.name.borrow_mut() = Some(new_name);

obj.emit("name-changed", &[&*imp.name.borrow()]).unwrap();
obj.emit("name-changed", &[&*imp.name.borrow()])
.expect("Failed to borrow name");

Some(old_name.to_value())
},
Expand Down Expand Up @@ -480,9 +487,10 @@ mod test {
Property("name", ..) => {
let name = value
.get()
.expect("type conformity checked by `Object::set_property`");
.expect("type conformity checked by 'Object::set_property'");
self.name.replace(name);
obj.emit("name-changed", &[&*self.name.borrow()]).unwrap();
obj.emit("name-changed", &[&*self.name.borrow()])
.expect("Failed to borrow name");
}
Property("child", ..) => {
// not stored, only used to test `set_property` with `Objects`
Expand Down Expand Up @@ -547,15 +555,15 @@ mod test {
#[test]
fn test_create() {
let type_ = SimpleObject::get_type();
let obj = Object::new(type_, &[]).unwrap();
let obj = Object::new(type_, &[]).expect("Object::new failed");

assert!(obj.get_type().is_a(&DummyInterface::static_type()));

assert_eq!(
obj.get_property("constructed")
.unwrap()
.expect("Failed to get 'constructed' property")
.get_some::<bool>()
.unwrap(),
.expect("Failed to get bool from 'constructed' property"),
true
);

Expand All @@ -567,7 +575,7 @@ mod test {
#[test]
fn test_create_child_object() {
let type_ = ChildObject::get_type();
let obj = Object::new(type_, &[]).unwrap();
let obj = Object::new(type_, &[]).expect("Object::new failed");

// ChildObject is a zero-sized type and we map that to the same pointer as the object
// itself. No private/impl data is allocated for zero-sized types.
Expand All @@ -577,51 +585,57 @@ mod test {

#[test]
fn test_set_properties() {
let obj = Object::new(SimpleObject::get_type(), &[]).unwrap();
let obj = Object::new(SimpleObject::get_type(), &[]).expect("Object::new failed");

assert!(obj
.get_property("name")
.unwrap()
.expect("Failed to get 'name' property")
.get::<&str>()
.unwrap()
.expect("Failed to get str from 'name' property")
.is_none());
assert!(obj.set_property("name", &"test").is_ok());
assert_eq!(
obj.get_property("name").unwrap().get::<&str>().unwrap(),
obj.get_property("name")
.expect("Failed to get 'name' property")
.get::<&str>()
.expect("Failed to get str from 'name' property"),
Some("test")
);

assert_eq!(
obj.set_property("test", &true).err().unwrap().description(),
obj.set_property("test", &true)
.err()
.expect("set_property failed")
.description(),
"property not found",
);

assert_eq!(
obj.set_property("constructed", &false)
.err()
.unwrap()
.expect("Failed to set 'constructed' property")
.description(),
"property is not writable",
);

assert_eq!(
obj.set_property("name", &false)
.err()
.unwrap()
.expect("Failed to set 'name' property")
.description(),
"property can't be set from the given type (expected: gchararray, got: gboolean)",
);

let other_obj = Object::new(SimpleObject::get_type(), &[]).unwrap();
let other_obj = Object::new(SimpleObject::get_type(), &[]).expect("Object::new failed");
assert_eq!(
obj.set_property("child", &other_obj)
.err()
.unwrap()
.expect("Failed to set 'child' property")
.description(),
"property can't be set from the given object type (expected: ChildObject, got: SimpleObject)",
);

let child = Object::new(ChildObject::get_type(), &[]).unwrap();
let child = Object::new(ChildObject::get_type(), &[]).expect("Object::new failed");
assert!(obj.set_property("child", &child).is_ok());
}

Expand All @@ -630,47 +644,59 @@ mod test {
use std::sync::{Arc, Mutex};

let type_ = SimpleObject::get_type();
let obj = Object::new(type_, &[("name", &"old-name")]).unwrap();
let obj = Object::new(type_, &[("name", &"old-name")]).expect("Object::new failed");

let name_changed_triggered = Arc::new(Mutex::new(false));
let name_changed_clone = name_changed_triggered.clone();
obj.connect("name-changed", false, move |args| {
let _obj = args[0].get::<Object>().unwrap().unwrap();
let name = args[1].get::<&str>().unwrap().unwrap();
let _obj = args[0]
.get::<Object>()
.expect("Failed to get args[0]")
.expect("Failed to get str from args[0]");
let name = args[1]
.get::<&str>()
.expect("Failed to get args[1]")
.expect("Failed to get str from args[1]");

assert_eq!(name, "new-name");
*name_changed_clone.lock().unwrap() = true;
*name_changed_clone.lock().expect("Failed to lock") = true;

None
})
.unwrap();
.expect("Failed to connect on 'name-changed'");

assert_eq!(
obj.get_property("name").unwrap().get::<&str>().unwrap(),
obj.get_property("name")
.expect("Failed to get 'name' property")
.get::<&str>()
.expect("Failed to get str from 'name' property"),
Some("old-name")
);
assert!(!*name_changed_triggered.lock().unwrap());
assert!(!*name_changed_triggered.lock().expect("Failed to lock"));

let old_name = obj
.emit("change-name", &[&"new-name"])
.unwrap()
.unwrap()
.expect("Failed to emit")
.expect("Failed to get value from emit")
.get::<String>()
.unwrap();
.expect("Failed to get str from emit");
assert_eq!(old_name, Some("old-name".to_string()));
assert!(*name_changed_triggered.lock().unwrap());
assert!(*name_changed_triggered.lock().expect("Failed to lock"));
}

#[test]
fn test_signal_return_expected_type() {
let obj = Object::new(SimpleObject::get_type(), &[]).unwrap();
let obj = Object::new(SimpleObject::get_type(), &[]).expect("Object::new failed");

obj.connect("create-string", false, move |_args| {
Some("return value".to_value())
})
.unwrap();
.expect("Failed to connect on 'create-string'");

let value = obj.emit("create-string", &[]).unwrap().unwrap();
let value = obj
.emit("create-string", &[])
.expect("Failed to emit")
.expect("Failed to get value from emit");
assert_eq!(value.get::<String>(), Ok(Some("return value".to_string())));
}

Expand All @@ -679,18 +705,21 @@ mod test {

#[test]
fn test_signal_return_expected_object_type() {
let obj = Object::new(SimpleObject::get_type(), &[]).unwrap();
let obj = Object::new(SimpleObject::get_type(), &[]).expect("Object::new failed");

obj.connect("create-child-object", false, move |_args| {
Some(
Object::new(ChildObject::get_type(), &[])
.unwrap()
.expect("Object::new failed")
.to_value(),
)
})
.unwrap();
.expect("Failed to connect on 'create-child-object'");

let value = obj.emit("create-child-object", &[]).unwrap().unwrap();
let value = obj
.emit("create-child-object", &[])
.expect("Failed to emit")
.expect("Failed to get value from emit");
assert!(value.type_().is_a(&ChildObject::static_type()));
}
}
8 changes: 4 additions & 4 deletions tests/clone.rs
Original file line number Diff line number Diff line change
Expand Up @@ -120,13 +120,13 @@ fn clone_default_value() {
#[test]
fn clone_panic() {
let state = Arc::new(Mutex::new(State::new()));
state.lock().unwrap().count = 20;
state.lock().expect("Failed to lock state mutex").count = 20;

let closure = {
let state2 = Arc::new(Mutex::new(State::new()));
clone!(@weak state2, @strong state => @default-return panic!(), move |_| {
state.lock().unwrap().count = 21;
state2.lock().unwrap().started = true;
state.lock().expect("Failed to lock state mutex").count = 21;
state2.lock().expect("Failed to lock state2 mutex").started = true;
10
})
};
Expand All @@ -139,5 +139,5 @@ fn clone_panic() {
assert!(false, "should panic");
}

assert_eq!(state.lock().unwrap().count, 20);
assert_eq!(state.lock().expect("Failed to lock state mutex").count, 20);
}