|
|
@@ -0,0 +1,131 @@
|
|
|
+//-----------------------------------------------------------------------------
|
|
|
+// Copyright (c) 2014 GarageGames, LLC
|
|
|
+//
|
|
|
+// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
+// of this software and associated documentation files (the "Software"), to
|
|
|
+// deal in the Software without restriction, including without limitation the
|
|
|
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
|
+// sell copies of the Software, and to permit persons to whom the Software is
|
|
|
+// furnished to do so, subject to the following conditions:
|
|
|
+//
|
|
|
+// The above copyright notice and this permission notice shall be included in
|
|
|
+// all copies or substantial portions of the Software.
|
|
|
+//
|
|
|
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
+// IN THE SOFTWARE.
|
|
|
+//-----------------------------------------------------------------------------
|
|
|
+
|
|
|
+#ifdef TORQUE_TESTS_ENABLED
|
|
|
+#include "testing/unitTesting.h"
|
|
|
+#include "component/simpleComponent.h"
|
|
|
+
|
|
|
+TEST(SimpleComponent, SimpleComponent)
|
|
|
+{
|
|
|
+ // When instantiating, and working with a SimObject in C++ code, such as
|
|
|
+ // a unit test, you *may not* allocate a SimObject off of the stack.
|
|
|
+ //
|
|
|
+ // For example:
|
|
|
+ // SimpleComponent sc;
|
|
|
+ // is a stack allocation. This memory is allocated off of the program stack
|
|
|
+ // when the function is called. SimObject deletion is done via SimObject::deleteObject()
|
|
|
+ // and the last command of this method is 'delete this;' That command will
|
|
|
+ // cause an assert if it is called on stack-allocated memory. Therefor, when
|
|
|
+ // instantiating SimObjects in C++ code, it is imperitive that you keep in
|
|
|
+ // mind that if any script calls 'delete()' on that SimObject, or any other
|
|
|
+ // C++ code calls 'deleteObject()' on that SimObject, it will crash.
|
|
|
+ SimpleComponent *sc = new SimpleComponent();
|
|
|
+
|
|
|
+ // SimObject::registerObject must be called on a SimObject before it is
|
|
|
+ // fully 'hooked in' to the engine.
|
|
|
+ //
|
|
|
+ // Tracing execution of this function will let you see onAdd get called on
|
|
|
+ // the component, and you will see it cache the interface we exposed.
|
|
|
+ sc->registerObject();
|
|
|
+
|
|
|
+ // It is *not* required that a component always be owned by a component (obviously)
|
|
|
+ // however I am using an owner so that you can trace execution of recursive
|
|
|
+ // calls to cache interfaces and such.
|
|
|
+ SimComponent *testOwner = new SimComponent();
|
|
|
+
|
|
|
+ // Add the test component to it's owner. This will set the 'mOwner' field
|
|
|
+ // of 'sc' to the address of 'testOwner'
|
|
|
+ testOwner->addComponent( sc );
|
|
|
+
|
|
|
+ // If you step-into this registerObject the same way as the previous one,
|
|
|
+ // you will be able to see the recursive caching of the exposed interface.
|
|
|
+ testOwner->registerObject();
|
|
|
+
|
|
|
+ // Now to prove that object composition is working properly, lets ask
|
|
|
+ // both of these components for their interface lists...
|
|
|
+
|
|
|
+ // The ComponentInterfaceList is a typedef for type 'VectorPtr<ComponentInterface *>'
|
|
|
+ // and it will be used by getInterfaces() to store the results of the interface
|
|
|
+ // query. This is the "complete" way to obtain an interface, and it is too
|
|
|
+ // heavy-weight for most cases. A simplified query will be performed next,
|
|
|
+ // to demonstrate the usage of both.
|
|
|
+ ComponentInterfaceList iLst;
|
|
|
+
|
|
|
+ // This query requests all interfaces, on all components, regardless of name
|
|
|
+ // or owner.
|
|
|
+ sc->getInterfaces( &iLst,
|
|
|
+ // This is the type field. I am passing NULL here to signify that the query
|
|
|
+ // should match all values of 'type' in the list.
|
|
|
+ NULL,
|
|
|
+
|
|
|
+ // The name field, let's pass NULL again just so when you trace execution
|
|
|
+ // you can see how queries work in the simple case, first.
|
|
|
+ NULL );
|
|
|
+
|
|
|
+ // Lets process the list that we've gotten back, and find the interface that
|
|
|
+ // we want.
|
|
|
+ SimpleComponentInterface *scQueriedInterface = NULL;
|
|
|
+
|
|
|
+ for( ComponentInterfaceListIterator i = iLst.begin(); i != iLst.end(); i++ )
|
|
|
+ {
|
|
|
+ scQueriedInterface = dynamic_cast<SimpleComponentInterface *>( *i );
|
|
|
+
|
|
|
+ if( scQueriedInterface != NULL )
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ AssertFatal( scQueriedInterface != NULL, "No valid SimpleComponentInterface was found in query" );
|
|
|
+
|
|
|
+ // Lets do it again, only we will execute the query on the parent instead,
|
|
|
+ // in a simplified way. Remember the parent component doesn't expose any
|
|
|
+ // interfaces at all, so the success of this behavior is entirely dependent
|
|
|
+ // on the recursive registration that occurs in registerInterfaces()
|
|
|
+ SimpleComponentInterface *ownerQueriedInterface = testOwner->getInterface<SimpleComponentInterface>();
|
|
|
+
|
|
|
+ AssertFatal( ownerQueriedInterface != NULL, "No valid SimpleComponentInterface was found in query" );
|
|
|
+
|
|
|
+ // We should now have two pointers to the same interface obtained by querying
|
|
|
+ // different components.
|
|
|
+ EXPECT_EQ( ownerQueriedInterface, scQueriedInterface )
|
|
|
+ << "This really shouldn't be possible to fail given the setup of the test";
|
|
|
+
|
|
|
+ // Lets call the method that was exposed on the component via the interface.
|
|
|
+ // Trace the execution of this function, if you wish.
|
|
|
+ EXPECT_TRUE( ownerQueriedInterface->isFortyTwo( 42 ) )
|
|
|
+ << "Don't panic, but it's a bad day in the component system.";
|
|
|
+ EXPECT_TRUE( scQueriedInterface->isFortyTwo( 42 ) )
|
|
|
+ << "Don't panic, but it's a bad day in the component system.";
|
|
|
+
|
|
|
+ // So there you have it. Writing a simple component that exposes a cached
|
|
|
+ // interface, and testing it. It's time to clean up.
|
|
|
+ testOwner->removeComponent( sc );
|
|
|
+
|
|
|
+ sc->deleteObject();
|
|
|
+ testOwner->deleteObject();
|
|
|
+
|
|
|
+ // Interfaces do not need to be freed. In Juggernaught, these will be ref-counted
|
|
|
+ // for more robust behavior. Right now, however, the values of our two interface
|
|
|
+ // pointers, scQueriedInterface and ownerQueriedInterface, reference invalid
|
|
|
+ // memory.
|
|
|
+};
|
|
|
+
|
|
|
+#endif
|
Daniel Buckmaster