mil.dod.th.ose.core/test/mil/dod/th/ose/core/impl/asset/TestAssetServiceProxy.java
@Test
    public void testInitializeProxy() throws FactoryException
    {
        // additional mock stubbing would be added here when the mock behavior needs to be unique for 
        // the specific method
        AssetProxy mockProxy = mock(AssetProxy.class);
        AssetInternal internalObj = mock(AssetInternal.class);
        
        // replay step (call the method being tested, setting up any parameters needed for the method 
        // call)
        Map<String, Object> map = new HashMap<>();
        m_SUT.initializeProxy(internalObj, mockProxy, map);
        
        // verify step
        //
        // - use verify() to make sure a particular method is called on a mocked object with the 
        // necessary parameters. Here we want to make sure the backed proxy class is initialized by the SUT
        verify(mockProxy).initialize(internalObj, map);
    }
/*
     * Each test method is annotated with @Test so the method is run when the test class is run.
     * 
     * Each test method should verify a single class method and particular state. Keep test methods 
     * simple.
     * 
     * The method name format should be "test<MethodUnderTest>_<state>" where _<state> is optional if 
     * the test is checking normal path of the method.
     * 
     * Each test method should have 3 parts: mock, replay and verify
     * 
     * Tests should have a short comment to explain what they do if not obvious by the method name
     */
Each test method is annotated with @Test so the method is run when the test class is run.

Each test method should verify a single class method and particular state. Keep test methods
simple.

The method name format should be "test_" where _ is optional if
the test is checking normal path of the method.

Each test method should have 3 parts: mock, replay and verify

Tests should have a short comment to explain what they do if not obvious by the method name
Each test method is annotated with @Test so the method is run when the test class is run . Each test method should verify a single class method and particular state . Keep test methods simple . The method name format should be " test_ " where _ is optional if the test is checking normal path of the method . Each test method should have 3 parts : mock replay and verify Tests should have a short comment to explain what they do if not obvious by the method name
@Test
    public void testInitializeProxy() throws FactoryException
    {
        AssetProxy mockProxy = mock(AssetProxy.class);
        AssetInternal internalObj = mock(AssetInternal.class);
        Map<String, Object> map = new HashMap<>();
        m_SUT.initializeProxy(internalObj, mockProxy, map);
         - use verify() to make sure a particular method is called on a mocked object with the 
         necessary parameters. Here we want to make sure the backed proxy class is initialized by the SUT
        verify(mockProxy).initialize(internalObj, map);
    }
@ Test public void testInitializeProxy ( ) throws FactoryException { AssetProxy mockProxy = mock ( AssetProxy . class ) ; AssetInternal internalObj = mock ( AssetInternal . class ) ; Map < String , Object > map = new HashMap < > ( ) ; m_SUT . initializeProxy ( internalObj , mockProxy , map ) ; verify ( mockProxy ) . initialize ( internalObj , map ) ; }
Each test method is annotated with @Test so the method is run when the test class is run.
Each test method is annotated with @Test so the method is run when the test class is run .
// additional mock stubbing would be added here when the mock behavior needs to be unique for  // the specific method // replay step (call the method being tested, setting up any parameters needed for the method  // call) // verify step // // - use verify() to make sure a particular method is called on a mocked object with the  // necessary parameters. Here we want to make sure the backed proxy class is initialized by the SUT