// TestGetOrElse_Something
func TestGetOrElse_Something(t *testing.T) {
	m := maybe.New(SOMETHING)
	assertGetOrElse(t, m, ELSE, SOMETHING)
}

// TestComposeMap_Increment_Double_Something
func TestComposeMap_Increment_Double_Something(t *testing.T) {
	f := maybe.ComposeMap(double, increment)
	_m := maybe.New(2)
	m := f(_m)
	assertSomethingValue(t, m, 6)
}

// TestComposeFilter_True_Something
func TestComposeFilter_True_Something(t *testing.T) {
	f := maybe.ComposeFilter(FilterTrue)
	m := maybe.New(SOMETHING)
	b := f(m)
	assertTrue(t, b)
}

// TestCall_Multi_Nil
func TestCall_Multi_Nil(t *testing.T) {
	arg1 := maybe.New("one")
	arg2 := maybe.Nothing()
	m := maybe.Call(MultiArgs_Last, arg1, arg2)
	assertNothing(t, m)
}

// TestComposeMap_Empty_Something
func TestComposeMap_Empty_Something(t *testing.T) {
	f := maybe.ComposeMap()
	_m := maybe.New(SOMETHING)
	m := f(_m)
	assertSomething(t, m)
}

// TestCall_Something_Echo
func TestCall_Something_Echo(t *testing.T) {
	_m := maybe.New(SOMETHING)
	m := maybe.Call(MapAny_Echo, _m)
	assertSomething(t, m)
}

// TestCall_Multi_Something_Last
func TestCall_Multi_Something_Last(t *testing.T) {
	arg1 := maybe.New("one")
	arg2 := maybe.New("two")
	m := maybe.Call(MultiArgs_Last, arg1, arg2)
	assertSomethingValue(t, m, "two")
}

// TestMap_Something_Any_Something
func TestMap_Something_Any_Something(t *testing.T) {
	_m := maybe.New(SOMETHING)
	m := _m.Map(MapAny_Echo)
	assertSomething(t, m)
}

// TestMap_Something_Ok_False
func TestMap_Something_Ok_False(t *testing.T) {
	_m := maybe.New(SOMETHING)
	m := _m.Map(MapOk_False)
	assertNothing(t, m)
}

// TestMap_Something_Nothing
func TestMap_Something_Nothing(t *testing.T) {
	_m := maybe.New(SOMETHING)
	m := _m.Map(MapNothing)
	assertNothing(t, m)
}

// TestMap_Something_Something
func TestMap_Something_Something(t *testing.T) {
	_m := maybe.New(SOMETHING)
	m := _m.Map(MapSomething)
	assertSomethingValue(t, m, MAPPED)
}

// TestMap_Something_NonFunc
func TestMap_Something_NonFunc(t *testing.T) {
	m := maybe.New(SOMETHING)
	f := func() { m.Map(0) } // int 0 is not a func
	assertPanic(t, f, MAP_FUNC_ERR)
}

// TestMap_Something_NoReturn
func TestMap_Something_NoReturn(t *testing.T) {
	m := maybe.New(SOMETHING)
	f := func() { m.Map(Map_NoReturn) }
	assertPanic(t, f, MAP_FUNC_RET_ERR)
}

// TestMap_Something_Nil
func TestMap_Something_Nil(t *testing.T) {
	m := maybe.New(SOMETHING)
	f := func() { m.Map(nil) }
	assertPanic(t, f, MAP_FUNC_ERR)
}

// TestFilter_Something_NoReturn
func TestFilter_Something_NoReturn(t *testing.T) {
	m := maybe.New(SOMETHING)
	f := func() { m.Filter(Filter_NoReturn) }
	assertPanic(t, f, FILTER_FUNC_ERR)
}

// TestMap_Something_Err_Panic
func TestMap_Something_Err_Panic(t *testing.T) {
	m := maybe.New(SOMETHING)
	f := func() { m.Map(MapErr_Panic) }
	assertPanic(t, f, MAP_PANIC)
}

// TestFilter_Multi_Something_True_True
func TestFilter_Multi_Something_True_True(t *testing.T) {
	_m := maybe.New(SOMETHING)
	m := _m.Filter(FilterTrue).Filter(FilterTrue)
	assertSomething(t, m)
}

// TestMap_Something_Err_Err
func TestMap_Something_Err_Err(t *testing.T) {
	_m := maybe.New(SOMETHING)
	m := _m.Map(MapErr_Err)
	assertError(t, m, ERROR_MSG)
}

// TestCall_Something_Double
func TestCall_Something_Double(t *testing.T) {
	_m := maybe.New(3)
	m := maybe.Call(double, _m)
	assertSomethingValue(t, m, 6)
}

// TestMap_Something_Err_Nil
func TestMap_Something_Err_Nil(t *testing.T) {
	_m := maybe.New(SOMETHING)
	m := _m.Map(MapErr_Nil)
	assertSomething(t, m)
}