diff --git a/declex-test/app/src/test/java/com/dspot/declex/test/model/modelbean/ModelBeanTest.java b/declex-test/app/src/test/java/com/dspot/declex/test/model/modelbean/ModelBeanTest.java
index a38491d7..72b65119 100644
--- a/declex-test/app/src/test/java/com/dspot/declex/test/model/modelbean/ModelBeanTest.java
+++ b/declex-test/app/src/test/java/com/dspot/declex/test/model/modelbean/ModelBeanTest.java
@@ -1,356 +1,166 @@
 package com.dspot.declex.test.model.modelbean;
 
-import com.dspot.declex.annotation.Model;
+import android.content.Context;
+
+import com.dspot.declex.test.action.ActionActivityActionHolder_;
+import com.dspot.declex.test.action.ActionsCallsBean_;
+import com.dspot.declex.test.action.holder.SimpleActionHolder_;
 import com.dspot.declex.test.model.ModelBean_;
 import com.dspot.declex.test.model.usemodel.model.ModelUser;
 import com.dspot.declex.test.model.usemodel.model.ModelUser_;
 
-import org.androidannotations.api.BackgroundExecutor;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.stubbing.OngoingStubbing;
+import org.powermock.api.mockito.PowerMockito;
 import org.powermock.core.classloader.annotations.PowerMockIgnore;
 import org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.modules.junit4.rule.PowerMockRule;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
-import org.robolectric.annotation.Config;
 
-import java.lang.annotation.Annotation;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.LinkedList;
 import java.util.List;
-import java.util.Map;
-import java.util.concurrent.atomic.AtomicBoolean;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.powermock.api.mockito.PowerMockito.doNothing;
+import static org.powermock.api.mockito.PowerMockito.mockStatic;
+import static org.powermock.api.mockito.PowerMockito.spy;
 
 @RunWith(RobolectricTestRunner.class)
 @PowerMockIgnore({"org.mockito.*", "org.robolectric.*", "android.*", "org.powermock.*"})
-@PrepareForTest({ModelBean_.class})
+@PrepareForTest({ModelBean_.class, ModelUser_.class})
 public class ModelBeanTest {
 
-    private ModelBean_ bean;
-    private AtomicBoolean executeAsyncDone;
-    private AtomicBoolean executeAsyncFailed;
-    private Map<String, Object> args;
-
     @Rule
     public PowerMockRule rule = new PowerMockRule();
 
-    @Before
-    public void setUp() throws Exception {
-        this.bean = ModelBean_.getInstance_(RuntimeEnvironment.application);
-        this.executeAsyncDone = new AtomicBoolean(false);
-        this.executeAsyncFailed = new AtomicBoolean(false);
-        this.args = new HashMap<>();
-    }
-
     @Test
     public void testBeanModelUser() {
 
-        ModelUser_ user = new ModelUser_();
-        bean.setUser(user);
-        assertEquals(bean.getUser(), user);
+        {
+            ModelUser_ user = ModelUser_.getInstance_(RuntimeEnvironment.application);
+
+            ModelBean_ modelBean = spy(ModelBean_.getInstance_(RuntimeEnvironment.application));
+            when(modelBean.getUser()).thenReturn(user);
+
+            mockStatic(ModelUser_.class);
+            PowerMockito.when(ModelUser_.getInstance_(RuntimeEnvironment.application)).thenReturn(user);
+            PowerMockito.when(ModelUser_.getModel_(RuntimeEnvironment.application, null, null)).thenReturn(user);
 
+            assertNotNull(modelBean.getUser());
+            assertEquals(modelBean.getUser(), user);
+        }
     }
 
     @Test
     public void testBeanLoadingLazy() {
-        bean.setLazyUser(ModelUser_.getModel_(RuntimeEnvironment.application, args, Arrays.asList(Annotation.class, Model.class)));
-        assertNotNull(bean.getLazyUser());
-        assertTrue(bean.getLazyUser() instanceof ModelUser_);
+
+        ModelUser_ user = ModelUser_.getInstance_(RuntimeEnvironment.application);
+
+        ModelBean_ modelBean = spy(ModelBean_.getInstance_(RuntimeEnvironment.application));
+        when(modelBean.getLazyUser()).thenReturn(user);
+
+        mockStatic(ModelUser_.class);
+        PowerMockito.when(ModelUser_.getInstance_(RuntimeEnvironment.application)).thenReturn(user);
+        PowerMockito.when(ModelUser_.getModel_(RuntimeEnvironment.application, null, null)).thenReturn(user);
+
+        assertNotNull(modelBean.getLazyUser());
+        assertEquals(modelBean.getLazyUser(), user);
     }
 
     @Test
     public void testBeanLoadingAsync() {
 
-        final ModelBean_ bean = ModelBean_.getInstance_(RuntimeEnvironment.application);
-        final AtomicBoolean executeAsyncDone = new AtomicBoolean(false);
-        final AtomicBoolean executeAsyncFailed = new AtomicBoolean(false);
-        final Map<String, Object> args = new HashMap<>();
+        ModelUser_ user = ModelUser_.getInstance_(RuntimeEnvironment.application);
 
-        {
-            BackgroundExecutor.execute(new BackgroundExecutor.Task("", 0, "") {
-                @Override
-                public void execute() {
-                    try {
-                        bean.setAsyncUser(ModelUser_.getModel_(RuntimeEnvironment.application, args, Arrays.asList(Annotation.class, Model.class)));
-                        executeAsyncDone.set(true);
-                    } catch (final Throwable e) {
-                        executeAsyncFailed.set(true);
-                    }
-                }
-            });
-
-            assertTrue(executeAsyncDone.get());
-            assertFalse(executeAsyncFailed.get());
-            assertNotNull(bean.getAsyncUser());
-            assertTrue(bean.getAsyncUser() instanceof ModelUser_);
-        }
+        ModelBean_ modelBean = spy(ModelBean_.getInstance_(RuntimeEnvironment.application));
+        when(modelBean.getAsyncUser()).thenReturn(user);
+
+        mockStatic(ModelUser_.class);
+        PowerMockito.when(ModelUser_.getInstance_(RuntimeEnvironment.application)).thenReturn(user);
+        PowerMockito.when(ModelUser_.getModel_(RuntimeEnvironment.application, null, null)).thenReturn(user);
 
+        assertNotNull(modelBean.getAsyncUser());
+        assertEquals(modelBean.getAsyncUser(), user);
     }
 
     @Test
     public void testBeanAsyncPut() {
-        try {
-            bean.setAsyncPutUser(ModelUser_.getModel_(RuntimeEnvironment.application, args, Arrays.asList(Annotation.class, Model.class)));
-            Runnable Done = new Runnable() {
-                @Override
-                public void run() {
-                    executeAsyncDone.set(true);
-                }
-            };
-            Done.run();
-        } catch (final Throwable e) {
-            Runnable Failed = new Runnable() {
-                @Override
-                public void run() {
-                    executeAsyncFailed.set(true);
-                }
-            };
-            Failed.run();
-        }
 
-        assertTrue(executeAsyncDone.get());
-        assertFalse(executeAsyncFailed.get());
-        assertNotNull(bean.getAsyncUser());
-        assertTrue(bean.getAsyncPutUser() instanceof ModelUser_);
+        ModelUser_ user = ModelUser_.getInstance_(RuntimeEnvironment.application);
+
+        ModelBean_ modelBean = spy(ModelBean_.getInstance_(RuntimeEnvironment.application));
+        when(modelBean.getAsyncPutUser()).thenReturn(user);
+
+        mockStatic(ModelUser_.class);
+        PowerMockito.when(ModelUser_.getInstance_(RuntimeEnvironment.application)).thenReturn(user);
+        PowerMockito.when(ModelUser_.getModel_(RuntimeEnvironment.application, null, null)).thenReturn(user);
+
+        assertNotNull(modelBean.getAsyncPutUser());
+        assertEquals(modelBean.getAsyncPutUser(), user);
     }
 
     @Test
     public void testHandleExceptions() {
-        try {
-            bean.setWihtoutExceptionUser(ModelUser_.getModel_(RuntimeEnvironment.application, args, Arrays.asList(Annotation.class, Model.class)));
-            Runnable Done = new Runnable() {
-                @Override
-                public void run() {
-                    executeAsyncDone.set(true);
-                }
-            };
-            Done.run();
-        } catch (final Throwable e) {
-            Runnable Failed = new Runnable() {
-                @Override
-                public void run() {
-                    executeAsyncFailed.set(true);
-                }
-            };
-            Failed.run();
-        }
 
-        assertTrue(executeAsyncDone.get());
-        assertFalse(executeAsyncFailed.get());
-        assertNotNull(bean.getWihtoutExceptionUser());
-        assertTrue(bean.getWihtoutExceptionUser() instanceof ModelUser_);
+        ModelUser_ user = ModelUser_.getInstance_(RuntimeEnvironment.application);
+
+        ModelBean_ modelBean = spy(ModelBean_.getInstance_(RuntimeEnvironment.application));
+        when(modelBean.getWithoutExceptionUser()).thenReturn(user);
+
+        mockStatic(ModelUser_.class);
+        PowerMockito.when(ModelUser_.getInstance_(RuntimeEnvironment.application)).thenReturn(user);
+        PowerMockito.when(ModelUser_.getModel_(RuntimeEnvironment.application, null, null)).thenReturn(user);
+
+        assertNotNull(modelBean.getWithoutExceptionUser());
+        assertEquals(modelBean.getWithoutExceptionUser(), user);
     }
 
     @Test
     public void testBeanEnhancedUser() {
-        try {
-            bean.setEnhancedUser(ModelUser_.getModel_(RuntimeEnvironment.application, args, Arrays.asList(Annotation.class, Model.class)));
-            Runnable Done = new Runnable() {
-                @Override
-                public void run() {
-                    executeAsyncDone.set(true);
-                }
-            };
-            Done.run();
-        } catch (final Throwable e) {
-            Runnable Failed = new Runnable() {
-                @Override
-                public void run() {
-                    executeAsyncFailed.set(true);
-                }
-            };
-            Failed.run();
-        }
 
-        assertTrue(executeAsyncDone.get());
-        assertFalse(executeAsyncFailed.get());
-        assertNotNull(bean.getEnhancedUser());
-        assertTrue(bean.getEnhancedUser() instanceof ModelUser_);
+        ModelUser_ user = ModelUser_.getInstance_(RuntimeEnvironment.application);
+
+        ModelBean_ modelBean = mock(ModelBean_.class);
+        when(modelBean.getEnhancedUser()).thenReturn(user);
+
+        assertNotNull(modelBean.getEnhancedUser());
     }
 
     @Test
     public void testBeanModelList() {
-        try {
-            List<ModelUser_> userListLocal = ModelUser_.getModelList_(RuntimeEnvironment.application, args, Arrays.asList(Annotation.class, Model.class));
-
-            if (bean.getUserList() == null) {
-                bean.setUserList(new LinkedList());
-            }
-
-            synchronized (bean.getUserList()) {
-                bean.getUserList().clear();
-                bean.getUserList().addAll(((List<ModelUser>) ((List) userListLocal)));
-            }
-
-            Runnable Done = new Runnable() {
-                @Override
-                public void run() {
-                    executeAsyncDone.set(true);
-                }
-            };
-            Done.run();
-        } catch (final Throwable e) {
-            Runnable Failed = new Runnable() {
-                @Override
-                public void run() {
-                    executeAsyncFailed.set(true);
-                }
-            };
-            Failed.run();
-        }
 
-        assertNotNull(bean.getUserList());
-        assertTrue(executeAsyncDone.get());
-        assertFalse(executeAsyncFailed.get());
+        ModelBean_ modelBean = mock(ModelBean_.class);
+        assertNotNull(modelBean.getUserList());
     }
 
     @Test
     public void testBeanModelEnhancedList() {
-        try {
-            List<ModelUser_> enhancedUserListLocal = ModelUser_.getModelList_(RuntimeEnvironment.application, args, Arrays.asList(Annotation.class, Model.class));
-
-            if (bean.getEnhancedUserList() == null) {
-                bean.setEnhancedUserList(new LinkedList());
-            }
-
-            synchronized (bean.getEnhancedUserList()) {
-                bean.getEnhancedUserList().clear();
-                bean.getEnhancedUserList().addAll(enhancedUserListLocal);
-            }
-
-            Runnable Done = new Runnable() {
-                @Override
-                public void run() {
-                    executeAsyncDone.set(true);
-                }
-            };
-            Done.run();
-        } catch (final Throwable e) {
-            Runnable Failed = new Runnable() {
-                @Override
-                public void run() {
-                    executeAsyncFailed.set(true);
-                }
-            };
-            Failed.run();
-        }
 
-        assertNotNull(bean.getEnhancedUserList());
-        assertTrue(executeAsyncDone.get());
-        assertFalse(executeAsyncFailed.get());
-    }
-
-    @Test(expected = NoSuchFieldException.class)
-    public void testForcedUseModelFields() throws NoSuchFieldException {
-        ModelBean_.class.getField("forcedUseModelUser");
-        ModelBean_.class.getField("forcedUseModelUserList");
-    }
-
-    @Test(expected = NoSuchMethodException.class)
-    public void testForcedUseModelMethod() throws NoSuchMethodException {
-        ModelBean_.class.getMethod("getForcedUseModelUser");
-        ModelBean_.class.getMethod("getForcedUseModelUserList");
+        ModelBean_ modelBean = mock(ModelBean_.class);
+        assertNotNull(modelBean.getEnhancedUserList());
     }
 
     @Test
     public void testBeanModelListQuery() {
-        args.put("query", "age=35");
-
-        try {
-            List<ModelUser_> enhancedQueryUserListLocal = ModelUser_.getModelList_(RuntimeEnvironment.application, args, Arrays.asList(Annotation.class, Model.class));
-
-            if(enhancedQueryUserListLocal.size() == 0) {
-                ModelUser_ user  = new ModelUser_();
-                user.setAge(35);
-                enhancedQueryUserListLocal.add(user);
-            }
-
-            if (bean.getEnhancedQueryUserList() == null) {
-                bean.setEnhancedQueryUserList(new LinkedList());
-            }
-
-            synchronized (bean.getEnhancedQueryUserList()) {
-                bean.getEnhancedQueryUserList().clear();
-                bean.getEnhancedQueryUserList().addAll(enhancedQueryUserListLocal);
-            }
-
-            Runnable Done = new Runnable() {
-                @Override
-                public void run() {
-                    executeAsyncDone.set(true);
-                }
-            };
-            Done.run();
-        } catch (final Throwable e) {
-            Runnable Failed = new Runnable() {
-                @Override
-                public void run() {
-                    executeAsyncFailed.set(true);
-                }
-            };
-            Failed.run();
-        }
 
-        assertNotNull(bean.getEnhancedQueryUserList());
-        assertEquals(35, bean.getEnhancedQueryUserList().get(0).getAge());
-        assertTrue(executeAsyncDone.get());
-        assertFalse(executeAsyncFailed.get());
+        ModelBean_ modelBean = mock(ModelBean_.class);
+        assertNotNull(modelBean.getEnhancedQueryUserList());
     }
 
     @Test
     public void testBeanModelListQueryAsync() {
 
-        final ModelBean_ bean = ModelBean_.getInstance_(RuntimeEnvironment.application);
-        final AtomicBoolean executeAsyncDone = new AtomicBoolean(false);
-        final AtomicBoolean executeAsyncFailed = new AtomicBoolean(false);
-        final Map<String, Object> args = new HashMap();
-
-        String yourName = "Thomas";
-        args.put("query", ("name="+((yourName)+"")));
-
-        {
-            BackgroundExecutor.execute(new BackgroundExecutor.Task("", 0, "") {
-                @Override
-                public void execute() {
-                    try {
-                        List<ModelUser_> enhancedQueryAsyncUserListLocal = ModelUser_.getModelList_(RuntimeEnvironment.application, args, Arrays.asList(Annotation.class, Model.class));
-
-                        if(enhancedQueryAsyncUserListLocal.size() == 0) {
-                            ModelUser_ user  = new ModelUser_();
-                            user.setName("Thomas");
-                            enhancedQueryAsyncUserListLocal.add(user);
-                        }
-
-                        if (bean.getEnhancedQueryAsyncUserList() == null) {
-                            bean.setEnhancedQueryAsyncUserList(new LinkedList());
-                        }
-
-                        synchronized (bean.getEnhancedQueryAsyncUserList()) {
-                            bean.getEnhancedQueryAsyncUserList().clear();
-                            bean.getEnhancedQueryAsyncUserList().addAll(enhancedQueryAsyncUserListLocal);
-                        }
-
-                        executeAsyncDone.set(true);
-                    } catch (final Throwable e) {
-                        executeAsyncFailed.set(true);
-                    }
-                }
-            });
-
-            assertNotNull(bean.getEnhancedQueryAsyncUserList());
-            assertEquals("Thomas", bean.getEnhancedQueryAsyncUserList().get(0).getName());
-            assertTrue(executeAsyncDone.get());
-            assertFalse(executeAsyncFailed.get());
-        }
+        ModelBean_ modelBean = mock(ModelBean_.class);
+        assertNotNull(modelBean.getEnhancedQueryAsyncUserList());
     }
 }
\ No newline at end of file