diff --git a/test/maybe/check.cc b/test/maybe/check.cc
index d1e2261ed..74acf7e38 100644
--- a/test/maybe/check.cc
+++ b/test/maybe/check.cc
@@ -1,3 +1,4 @@
+#include "assert.h"
 #include "napi.h"
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)
 
@@ -6,11 +7,52 @@ using namespace Napi;
 namespace {
 
 void VoidCallback(const CallbackInfo& info) {
-  Function fn = info[0].As<Function>();
+  Napi::Function fn = info[0].As<Function>();
+  Maybe<Value> ret = fn.Call({});
 
-  Maybe<Value> it = fn.Call({});
+  assert(ret.IsNothing() == true);
+  assert(ret.IsJust() == false);
 
-  it.Check();
+  Napi::Value placeHolder = Napi::Number::New(info.Env(), 12345);
+  Napi::Value unwrappedValue = ret.UnwrapOr(placeHolder);
+
+  assert(unwrappedValue.As<Number>().Uint32Value() == 12345);
+
+  assert(ret.UnwrapTo(&placeHolder) == false);
+  assert(placeHolder.As<Number>().Uint32Value() == 12345);
+
+  ret.Check();
+}
+
+void TestMaybeOperatorOverload(const CallbackInfo& info) {
+  Napi::Function fn_a = info[0].As<Function>();
+  Napi::Function fn_b = info[1].As<Function>();
+
+  assert(fn_a.Call({}) == fn_a.Call({}));
+  assert(fn_a.Call({}) != fn_b.Call({}));
+}
+
+void NormalJsCallback(const CallbackInfo& info) {
+  Napi::Function fn = info[0].As<Function>();
+  uint32_t magic_number = info[1].As<Number>().Uint32Value();
+
+  Maybe<Value> ret = fn.Call({});
+
+  assert(ret.IsNothing() == false);
+  assert(ret.IsJust() == true);
+
+  Napi::Value unwrappedValue = ret.Unwrap();
+  assert(unwrappedValue.IsNumber() == true);
+
+  assert(unwrappedValue.As<Number>().Uint32Value() == magic_number);
+
+  unwrappedValue =
+      ret.UnwrapOr(Napi::Number::New(info.Env(), magic_number - 1));
+  assert(unwrappedValue.As<Number>().Uint32Value() == magic_number);
+
+  Napi::Value placeHolder = Napi::Number::New(info.Env(), magic_number - 1);
+  assert(ret.UnwrapTo(&placeHolder) == true);
+  assert(placeHolder.As<Number>().Uint32Value() == magic_number);
 }
 
 }  // end anonymous namespace
@@ -18,6 +60,10 @@ void VoidCallback(const CallbackInfo& info) {
 Object InitMaybeCheck(Env env) {
   Object exports = Object::New(env);
   exports.Set("voidCallback", Function::New(env, VoidCallback));
+  exports.Set("normalJsCallback", Function::New(env, NormalJsCallback));
+  exports.Set("testMaybeOverloadOp",
+              Function::New(env, TestMaybeOperatorOverload));
   return exports;
 }
+
 #endif
diff --git a/test/maybe/index.js b/test/maybe/index.js
index ce6ce76f2..65f8643c2 100644
--- a/test/maybe/index.js
+++ b/test/maybe/index.js
@@ -34,6 +34,16 @@ function test (binding) {
 }
 
 function child (binding) {
+  const MAGIC_NUMBER = 12459062;
+  binding.normalJsCallback(() => {
+    return MAGIC_NUMBER;
+  }, MAGIC_NUMBER);
+
+  binding.testMaybeOverloadOp(
+    () => { return MAGIC_NUMBER; },
+    () => { throw Error('Foobar'); }
+  );
+
   binding.voidCallback(() => {
     throw new Error('foobar');
   });