void _TestGusdErrorTransport() { std::cout << "Test GusdErrorTransport" << std::endl; // Basic parallel transport test. { UT_ErrorManager::Scope scope; GusdErrorTransport transport; auto fn = [&]() { UT_ErrorManager::Scope threadScope; // XXX: Sleep to trick tbb into thinking this is an expensive // task. Otherwise it might run single-threaded. sleep(1); GusdAutoErrorTransport autoTransport(transport); GUSD_ERR().Msg("error"); }; UTparallelInvoke(true, fn, fn); TF_AXIOM(scope.getErrorManager().getNumErrors() == 2); std::string msg = GusdGetErrors(); TF_AXIOM(TfStringContains(msg, "error")); } }
static bool Test_TfRegistryManagerUnload() { TfDebug::Enable(TF_DLOPEN); TfDebug::Enable(TF_DLCLOSE); // Compute path to test library. std::string libraryPath; TF_AXIOM(ArchGetAddressInfo((void*)Test_TfRegistryManagerUnload, &libraryPath, NULL, NULL, NULL)); libraryPath = TfGetPathName(libraryPath) + "lib/libTestTfRegistryFunctionPlugin.so"; // Make sure that this .so exists printf("Checking test shared lib: %s\n", libraryPath.c_str()); TF_AXIOM(!ArchFileAccess(libraryPath.c_str(), R_OK)); // Load and unload a shared library that has a registration function // before anyone subscribes to that type. _LoadAndUnloadSharedLibrary(libraryPath); // Subscribe to the registry function from our unloaded shared library. // This will crash as in bug 99729 if the registry manager fails to remove // functions from the unloaded library. TfRegistryManager::GetInstance() .SubscribeTo<Tf_TestRegistryFunctionPlugin>(); // Load and unload again just to make sure that we still don't crash. _LoadAndUnloadSharedLibrary(libraryPath); return true; }
static void _LoadAndUnloadSharedLibrary(const std::string & libraryPath) { std::string dlErrorMsg; void * handle = TfDlopen(libraryPath.c_str(), ARCH_LIBRARY_NOW, &dlErrorMsg); TF_AXIOM(handle); TF_AXIOM(dlErrorMsg.empty()); TF_AXIOM(!TfDlclose(handle)); }
//virtual UsdPrim MayaNurbsCurveWriter::write(const UsdTimeCode &usdTime) { // == Write UsdGeomNurbsCurves primSchema = UsdGeomNurbsCurves::Define(getUsdStage(), getUsdPath()); TF_AXIOM(primSchema); UsdPrim prim = primSchema.GetPrim(); TF_AXIOM(prim); // Write the attrs writeNurbsCurveAttrs(usdTime, primSchema); return prim; }
/* virtual */ UsdPrim MayaCameraWriter::write(const UsdTimeCode &usdTime) { // == Write UsdGeomCamera primSchema = UsdGeomCamera::Define(getUsdStage(), getUsdPath()); TF_AXIOM(primSchema); UsdPrim prim = primSchema.GetPrim(); TF_AXIOM(prim); // Write parent class attrs writeTransformAttrs(usdTime, primSchema); // Write the attrs writeCameraAttrs(usdTime, primSchema); return prim; }
int main() { TestTemplates(); #ifdef PXR_PYTHON_SUPPORT_ENABLED TF_AXIOM(!Py_IsInitialized()); #endif // PXR_PYTHON_SUPPORT_ENABLED }
//virtual UsdPrim MayaMeshWriter::write(const UsdTimeCode &usdTime) { if ( !isMeshValid() ) { return UsdPrim(); } // Get schema UsdGeomMesh primSchema = UsdGeomMesh::Define(getUsdStage(), getUsdPath()); TF_AXIOM(primSchema); UsdPrim meshPrim = primSchema.GetPrim(); TF_AXIOM(meshPrim); // Write the attrs writeMeshAttrs(usdTime, primSchema); return meshPrim; }
const char* _ConstructStringNeverReached() { // Should never reach this point. This indicates that GUSD_GENERIC_ERR // is failing to elide its message-posting as expected. TF_AXIOM(false); return "invalid"; }
void _TestBasicErrorFn(UT_ErrorSeverity sev, const FN1& oneArgFn, const FN2& twoArgFn) { { UT_ErrorManager::Scope scope; oneArgFn("foo"); TF_AXIOM(scope.getSeverity() == sev); TF_AXIOM(sev == UT_ERROR_NONE || GusdGetErrors() == "foo"); } { UT_ErrorManager::Scope scope; twoArgFn("foo %s", "bar"); TF_AXIOM(scope.getSeverity() == sev); TF_AXIOM(sev == UT_ERROR_NONE || GusdGetErrors() == "foo bar"); } }
static void _TestSerialization( const std::vector<std::shared_ptr<TraceCollection>>& testCols, std::string fileName) { std::stringstream test; bool written = false; if (testCols.size() == 1 ) { written = TraceSerialization::Write(test, testCols[0]); } else { written = TraceSerialization::Write(test, testCols); } TF_AXIOM(written); // Write out the file { std::ofstream ostream(fileName); ostream << test.str(); } // Read a collection from the file just written std::shared_ptr<TraceCollection> collection; { std::ifstream istream(fileName); collection = TraceSerialization::Read(istream); TF_AXIOM(collection); } std::string stringRepr = test.str(); std::stringstream test2; bool written2 = TraceSerialization::Write(test2, collection); TF_AXIOM(written2); std::string stringRepr2 = test2.str(); // This comparison might be too strict. if (stringRepr != stringRepr2) { std::cout << "Written:\n" << stringRepr << "\n"; std::cout << "Reconstruction:\n" << stringRepr2 << "\n"; } TF_AXIOM(stringRepr == stringRepr2); }
int main(int argc, char** argv) { TestEnsureParentCtorForCopying(); TestPrimQueries(); printf("Passed!\n"); #ifdef PXR_PYTHON_SUPPORT_ENABLED TF_AXIOM(!Py_IsInitialized()); #endif // PXR_PYTHON_SUPPORT_ENABLED return EXIT_SUCCESS; }
static void TestNullptrComparisons() { NodeRefPtr p; TF_AXIOM(p == nullptr); TF_AXIOM(!(p != nullptr)); TF_AXIOM(!(p < nullptr)); TF_AXIOM(p <= nullptr); TF_AXIOM(!(p > nullptr)); TF_AXIOM(p >= nullptr); // These should be exactly the same as the above comparisons to nullptr, // but are included to verify that the code compiles. TF_AXIOM(p == NULL); TF_AXIOM(NULL == p); }
void testPaths(char const *paths[], int expect) { Sdf_PathParserContext context; // Initialize the scanner, allowing it to be reentrant. SdfPathYylex_init(&context.scanner); while(*paths) { printf("testing: %s\n", *paths); SdfPathYy_scan_string(*paths, context.scanner); int result = SdfPathYyparse(&context); // Report parse errors. if (result != expect) { fprintf(stderr, "parse error: %s in %s\n", context.errStr.c_str(), *paths); TF_AXIOM(result == expect); } // Report mismatches between original string and the string // representation of the parsed path. We allow whitespace to // be different. if (result == 0) { std::string s = context.node->GetPathToken().GetString(); if (s != TfStringReplace(*paths, " ", "")) { fprintf(stderr, "mismatch: %s -> %s\n", *paths, s.c_str()); TF_AXIOM(s == *paths); } } ++paths; } // Clean up. SdfPathYylex_destroy(context.scanner); }
void _TestGusdTfErrorScope() { std::cout << "Test GusdTfErrorScope" << std::endl; // Severity is user-configured. Test each severity level. for(int i = UT_ERROR_MESSAGE; i < UT_NUM_ERROR_SEVERITIES; ++i) { auto sev = static_cast<UT_ErrorSeverity>(i); UT_ErrorManager::Scope scope; { GusdTfErrorScope tfErrScope(sev); TF_CODING_ERROR("(coding error)"); TF_RUNTIME_ERROR("(runtime error)"); } TF_AXIOM(scope.getErrorManager().getNumErrors() == 2); TF_AXIOM(scope.getSeverity() == sev); TF_AXIOM(TfStringContains(GusdGetErrors(), "(coding error)")); TF_AXIOM(TfStringContains(GusdGetErrors(), "(runtime error)")); } // Setting severity of NONE means errors are ignored. { UT_ErrorManager::Scope scope; { GusdTfErrorScope tfErrScope(UT_ERROR_NONE); TF_CODING_ERROR("(coding error)"); TF_RUNTIME_ERROR("(runtime error)"); } TF_AXIOM(scope.getErrorManager().getNumErrors() == 0); TF_AXIOM(scope.getSeverity() == UT_ERROR_NONE); } // Test workaround for errors containing '<>' chars, which normally // won't display in node MMB menus due to HTML formatting. { UT_ErrorManager::Scope scope; { GusdTfErrorScope tfErrScope; TF_CODING_ERROR("<foo>"); } TF_AXIOM(TfStringContains(GusdGetErrors(), "[foo]")); } }
int main(int argc, char *argv[]) { // GfVec2f { float vals[] = { 1.0f, 2.0f }; GfVec2f v(vals); TF_AXIOM(v == GfVec2f(1,2)); float const *f = v.GetArray(); TF_AXIOM(f[0] == 1 and f[1] == 2); } // GfVec2i { int vals[] = { 1, 2 }; GfVec2i v(vals); TF_AXIOM(v == GfVec2i(1,2)); int const *i = v.GetArray(); TF_AXIOM(i[0] == 1 and i[1] == 2); v.Set(0, 1); TF_AXIOM(v == GfVec2i(0,1)); } // GfVec3i { int vals[] = { 1, 2, 3 }; GfVec3i v(vals); TF_AXIOM(v == GfVec3i(1,2,3)); int const *i = v.GetArray(); TF_AXIOM(i[0] == 1 and i[1] == 2 and i[2] == 3); v.Set(0, 1, 2); TF_AXIOM(v == GfVec3i(0,1,2)); } // GfVec4i { int vals[] = { 1, 2, 3, 4 }; GfVec4i v(vals); TF_AXIOM(v == GfVec4i(1,2,3,4)); int const *i = v.GetArray(); TF_AXIOM(i[0] == 1 and i[1] == 2 and i[2] == 3 and i[3] == 4); v.Set(0, 1, 2, 3); TF_AXIOM(v == GfVec4i(0,1,2,3)); } // GfVec3f { float vals[] = { 1.0f, 2.0f, 3.0f }; GfVec3f v(vals); TF_AXIOM(v == GfVec3f(1,2,3)); float const *f = v.GetArray(); TF_AXIOM(f[0] == 1 and f[1] == 2 and f[2] == 3); } // GfVec4f { float vals[] = { 1.0f, 2.0f, 3.0f, 4.0f }; GfVec4f v(vals); TF_AXIOM(v == GfVec4f(1,2,3,4)); float const *f = v.GetArray(); TF_AXIOM(f[0] == 1 and f[1] == 2 and f[2] == 3 and f[3] == 4); } // GfSize2, GfSize3 { size_t vals[] = {1, 2, 3}; TF_AXIOM(GfSize2(vals) == GfSize2(1,2)); TF_AXIOM(GfSize3(vals) == GfSize3(1,2,3)); } // GfMatrix2d { double vals[2][2] = {{1, 0}, {0, 1}}; TF_AXIOM(GfMatrix2d(vals) == GfMatrix2d(1)); GfMatrix2d m(vals); double const *d = m.GetArray(); TF_AXIOM(d[0] == 1 and d[1] == 0 and d[2] == 0 and d[3] == 1); } // GfMatrix2f { float vals[2][2] = {{1, 0}, {0, 1}}; TF_AXIOM(GfMatrix2f(vals) == GfMatrix2f(1)); GfMatrix2f m(vals); float const *f = m.GetArray(); TF_AXIOM(f[0] == 1 and f[1] == 0 and f[2] == 0 and f[3] == 1); } // GfMatrix3d { double vals[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}; TF_AXIOM(GfMatrix3d(vals) == GfMatrix3d(1)); GfMatrix3d m(vals); double const *d = m.GetArray(); TF_AXIOM(d[0] == 1 and d[1] == 0 and d[2] == 0 and d[3] == 0 and d[4] == 1 and d[5] == 0 and d[6] == 0 and d[7] == 0 and d[8] == 1); } // GfMatrix4d { double vals[4][4] = {{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}}; TF_AXIOM(GfMatrix4d(vals) == GfMatrix4d(1)); GfMatrix4d m(vals); double const *d = m.GetArray(); TF_AXIOM(d[ 0] == 1 and d[ 1] == 0 and d[ 2] == 0 and d[ 3] == 0 and d[ 4] == 0 and d[ 5] == 1 and d[ 6] == 0 and d[ 7] == 0 and d[ 8] == 0 and d[ 9] == 0 and d[10] == 1 and d[11] == 0 and d[12] == 0 and d[13] == 0 and d[14] == 0 and d[15] == 1); } // half { float halfPosInf = half::posInf(); TF_AXIOM(not std::isfinite(halfPosInf)); TF_AXIOM(std::isinf(halfPosInf)); float halfNegInf = half::negInf(); TF_AXIOM(not std::isfinite(halfNegInf)); TF_AXIOM(std::isinf(halfNegInf)); float halfqNan = half::qNan(); TF_AXIOM(std::isnan(halfqNan)); float halfsNan = half::sNan(); TF_AXIOM(std::isnan(halfsNan)); } return 0; }
const PcpPrimIndex & Usd_PrimData::GetSourcePrimIndex() const { TF_AXIOM(_primIndex); return *_primIndex; }
// virtual bool MayaNurbsCurveWriter::writeNurbsCurveAttrs(const UsdTimeCode &usdTime, UsdGeomNurbsCurves &primSchema) { MStatus status = MS::kSuccess; // Write parent class attrs writeTransformAttrs(usdTime, primSchema); // Return if usdTime does not match if shape is animated if (usdTime.IsDefault() == isShapeAnimated() ) { // skip shape as the usdTime does not match if shape isAnimated value return true; } MFnDependencyNode fnDepNode(getDagPath().node(), &status); MString name = fnDepNode.name(); MFnNurbsCurve curveFn( getDagPath(), &status ); if (!status) { MGlobal::displayError("MFnNurbsCurve() failed for MayaNurbsCurveWriter"); return false; } // Get curve attrs ====== unsigned int numCurves = 1; // Assuming only 1 curve for now VtArray<int> curveOrder(numCurves); VtArray<int> curveVertexCounts(numCurves); VtArray<float> curveWidths(numCurves); VtArray<GfVec2d> ranges(numCurves); curveOrder[0] = curveFn.degree()+1; curveVertexCounts[0] = curveFn.numCVs(); TF_AXIOM(curveOrder[0] <= curveVertexCounts[0] ); curveWidths[0] = 1.0; // TODO: Retrieve from custom attr double mayaKnotDomainMin; double mayaKnotDomainMax; status = curveFn.getKnotDomain(mayaKnotDomainMin, mayaKnotDomainMax); TF_AXIOM(status == MS::kSuccess); ranges[0][0] = mayaKnotDomainMin; ranges[0][1] = mayaKnotDomainMax; MPointArray mayaCurveCVs; status = curveFn.getCVs(mayaCurveCVs, MSpace::kObject); TF_AXIOM(status == MS::kSuccess); VtArray<GfVec3f> points(mayaCurveCVs.length()); // all CVs batched together for (unsigned int i=0; i < mayaCurveCVs.length(); i++) { points[i].Set(mayaCurveCVs[i].x, mayaCurveCVs[i].y, mayaCurveCVs[i].z); } MDoubleArray mayaCurveKnots; status = curveFn.getKnots(mayaCurveKnots); TF_AXIOM(status == MS::kSuccess); VtArray<double> curveKnots(mayaCurveKnots.length()); // all knots batched together for (unsigned int i=0; i < mayaCurveKnots.length(); i++) { curveKnots[i] = mayaCurveKnots[i]; } // Gprim VtArray<GfVec3f> extent(2); UsdGeomCurves::ComputeExtent(points, curveWidths, &extent); primSchema.CreateExtentAttr().Set(extent, usdTime); // Curve primSchema.GetOrderAttr().Set(curveOrder); // not animatable primSchema.GetCurveVertexCountsAttr().Set(curveVertexCounts); // not animatable primSchema.GetWidthsAttr().Set(curveWidths); // not animatable primSchema.GetKnotsAttr().Set(curveKnots); // not animatable primSchema.GetRangesAttr().Set(ranges); // not animatable primSchema.GetPointsAttr().Set(points, usdTime); // CVs // TODO: Handle periodic and non-periodic cases return true; }
static bool TestTF_PP_EAT_PARENS() { #define _STR BOOST_PP_STRINGIZE #define _EAT TF_PP_EAT_PARENS TF_AXIOM(not strcmp(_STR(), "")); TF_AXIOM(not strcmp(_STR(_EAT()), "")); TF_AXIOM(not strcmp(_STR(_EAT(())), "")); TF_AXIOM(not strcmp(_STR(_EAT(a)), "a")); TF_AXIOM(not strcmp(_STR(_EAT(a)), "a")); TF_AXIOM(not strcmp(_STR(_EAT((a))), "a")); TF_AXIOM(not strcmp(_STR(_EAT(((a)))), "(a)")); TF_AXIOM(not strcmp(_STR(_EAT(_EAT(((a))))), "a")); TF_AXIOM(not strcmp(_STR(_EAT(_EAT((((a)))))), "(a)")); TF_AXIOM(not strcmp(_STR(_EAT(_EAT(_EAT((((a))))))), "a")); TF_AXIOM(not strcmp(_STR((_EAT((<a, b>)))), "(<a, b>)")); TF_AXIOM(not strcmp(_STR((_EAT(_EAT(((<a, b>)))))), "(<a, b>)")); TF_AXIOM(not strcmp(_STR((_EAT(_EAT(_EAT((((<a, b>)))))))), "(<a, b>)")); TF_AXIOM(not strcmp(_STR(_EAT(f(a))), "f(a)")); //XXX: This isn't quite what we want; we would only expect _EAT() // to remove the outermost _matching_ parentheses. // See bug 8584. TF_AXIOM(not strcmp(_STR(_EAT((x)(x))), "x(x)")); TF_AXIOM(not strcmp(_STR(_EAT((x)f(x))), "xf(x)")); TF_AXIOM(not strcmp(_STR(_EAT((x)(x)(x))), "x(x)(x)")); //TF_AXIOM(not strcmp(_STR(_EAT((x)(x))), "(x)(x)")); //TF_AXIOM(not strcmp(_STR(_EAT((x)f(x))), "(x)f(x)")); //TF_AXIOM(not strcmp(_STR(_EAT((x)(x)(x))), "(x)(x)(x)")); #undef _STR #undef _EAT return true; }
static bool Test_TfRefPtr() { TestConversions(); TestNullptrComparisons(); NodeRefPtr chain1 = MakeChain(10); NodeRefPtr chain2 = MakeChain(5); NodePtr gChain1 = chain1; NodePtr gChain2 = chain2; TF_AXIOM(chain1->GetLength() == 10); TF_AXIOM(chain2->GetLength() == 5); TF_AXIOM(gChain1->GetLength() == 10); TF_AXIOM(gChain2->GetLength() == 5); std::cout << "total nodes (should be 15): " << Node::GetTotalNodeCount() << std::endl; NodeRefPtr start = Node::New(); start->SetChild(chain1); chain1 = TfNullPtr; TF_AXIOM(gChain1->GetLength() == 10); TF_AXIOM(start->GetLength() == 11); std::cout << "total nodes (should be one more than previous): " << Node::GetTotalNodeCount() << std::endl; start->SetChild(gChain2); chain2 = TfNullPtr; TF_AXIOM(start->GetLength() == 6); TF_AXIOM(!gChain1); TF_AXIOM(gChain2); TF_AXIOM(start->GetLength() == start->GetTail()->GetRevLength()); std::cout << "total nodes (should be 10 less than last): " << Node::GetTotalNodeCount() << std::endl; start = TfNullPtr; TF_AXIOM(!gChain1); TF_AXIOM(!gChain2); std::cout << "total nodes (should be zero): " << Node::GetTotalNodeCount() << std::endl; TF_AXIOM(Node::GetTotalNodeCount() == 0); chain1 = MakeChain(5); gChain2 = chain2 = MakeChain(5); chain1->GetTail()->SetChild(chain2); TF_AXIOM(gChain2->GetRevLength() == 6); chain1 = TfNullPtr; TF_AXIOM(gChain2->GetRevLength() == 1); chain2 = TfNullPtr; TF_AXIOM(!gChain2); TF_AXIOM(Node::GetTotalNodeCount() == 0); SuperNodeRefPtr superPtr = SuperNode::New(); NodeRefPtr basePtr = superPtr; NodePtr baseBackPtr = basePtr; TF_AXIOM(TfDynamic_cast<SuperNodeRefPtr>(basePtr) == superPtr); TF_AXIOM(TfSafeDynamic_cast<SuperNodeRefPtr>(basePtr) == superPtr); TF_AXIOM(TfDynamic_cast<SuperNodePtr>(baseBackPtr) == superPtr); TF_AXIOM(TfSafeDynamic_cast<SuperNodePtr>(baseBackPtr) == superPtr); // Test swap { const NodeRefPtr n1 = Node::New(); const NodeRefPtr n2 = Node::New(); NodeRefPtr a = n1; NodeRefPtr b = n2; TF_AXIOM(a); TF_AXIOM(b); TF_AXIOM(a != b); TF_AXIOM(a == n1); TF_AXIOM(b == n2); a.swap(b); TF_AXIOM(a == n2); TF_AXIOM(b == n1); // Test self-swap a.swap(a); TF_AXIOM(a == n2); b.swap(b); TF_AXIOM(b == n1); } // Test move constructor and assignment operators { NodeRefPtr n1 = Node::New(); Node* n1Ptr = get_pointer(n1); TF_AXIOM(n1); NodeRefPtr n2(std::move(n1)); TF_AXIOM(n2); TF_AXIOM(get_pointer(n2) == n1Ptr); TF_AXIOM(!n1); n1 = Node::New(); n1Ptr = get_pointer(n1); TF_AXIOM(n1); n2 = std::move(n1); TF_AXIOM(n2); TF_AXIOM(get_pointer(n2) == n1Ptr); TF_AXIOM(!n1); } // Test move constructor and assignment operators on // convertible pointer types. { SuperNodeRefPtr subNode = SuperNode::New(); SuperNode* subNodePtr = get_pointer(subNode); TF_AXIOM(subNode); NodeRefPtr baseNode(std::move(subNode)); TF_AXIOM(baseNode); TF_AXIOM(get_pointer(baseNode) == subNodePtr); TF_AXIOM(!subNode); subNode = SuperNode::New(); subNodePtr = get_pointer(subNode); TF_AXIOM(subNode); baseNode = std::move(subNode); TF_AXIOM(baseNode); TF_AXIOM(get_pointer(baseNode) == subNodePtr); TF_AXIOM(!subNode); } return true; }
int main() { TestTemplates(); TF_AXIOM(!Py_IsInitialized()); }
static bool TestTF_NUM_ARGS() { TF_AXIOM(TF_NUM_ARGS() == 0); TF_AXIOM(TF_NUM_ARGS( ) == 0); TF_AXIOM(TF_NUM_ARGS(/**/) == 0); TF_AXIOM(TF_NUM_ARGS(/*Test*/) == 0); TF_AXIOM(TF_NUM_ARGS(()) == 1); TF_AXIOM(TF_NUM_ARGS(f()) == 1); TF_AXIOM(TF_NUM_ARGS(f()()) == 1); TF_AXIOM(TF_NUM_ARGS((a)) == 1); TF_AXIOM(TF_NUM_ARGS(((a))) == 1); TF_AXIOM(TF_NUM_ARGS((()())) == 1); //XXX: Figure out why these doesn't work. See bug 8584. //TF_AXIOM(TF_NUM_ARGS(()f) == 1); //TF_AXIOM(TF_NUM_ARGS(()()) == 1); TF_AXIOM(TF_NUM_ARGS(a) == 1); TF_AXIOM(TF_NUM_ARGS(a, b) == 2); TF_AXIOM(TF_NUM_ARGS(a, b, c) == 3); TF_AXIOM(TF_NUM_ARGS(a, b, c, d) == 4); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e) == 5); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f) == 6); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g) == 7); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h) == 8); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i) == 9); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j) == 10); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k) == 11); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l) == 12); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m) == 13); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m, n) == 14); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) == 15); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) == 16); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) == 17); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) == 18); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) == 19); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) == 20); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) == 21); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) == 22); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) == 23); TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) == 24); //XXX: TF_MAX_ARITY of 25 should work... See bug 8584. //TF_AXIOM(TF_NUM_ARGS(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) == 25); return true; }
static TraceEventTree::MarkerValues GetTimeOfMarker(const std::string& MarkerName, const TraceEventTree::MarkerValuesMap& Markers) { TraceEventTree::MarkerValuesMap::const_iterator it = Markers.find(TfToken(MarkerName)); TF_AXIOM(it!= Markers.end()); return it->second; }
int main(int argc, char* argv[]) { TraceCollector* collector = &TraceCollector::GetInstance(); TraceReporterPtr reporter = TraceReporter::GetGlobalReporter(); collector->SetEnabled(true); TestMarkerMacro(); collector->SetEnabled(false); reporter->ReportChromeTracing(std::cout); TraceEventTreeRefPtr timeline = reporter->GetEventTree(); TF_AXIOM(timeline); const TraceEventTree::MarkerValuesMap& Markers = timeline->GetMarkers(); // Test that the Markers are recorded in order TraceEvent::TimeStamp asTime = GetTimeOfMarker("Static Marker A", Markers)[0].first; TF_AXIOM(GetTimeOfMarker("Static Marker A", Markers).size() == 1); TraceEvent::TimeStamp bsTime = GetTimeOfMarker("Static Marker B", Markers)[0].first; TraceEvent::TimeStamp csTime = GetTimeOfMarker("Static Marker C", Markers)[0].first; TF_AXIOM(asTime < bsTime && bsTime < csTime); TraceEvent::TimeStamp adTime = GetTimeOfMarker("Dynamic Marker A", Markers)[0].first; TraceEvent::TimeStamp bdTime = GetTimeOfMarker("Dynamic Marker B", Markers)[0].first; TraceEvent::TimeStamp cdTime = GetTimeOfMarker("Dynamic Marker C", Markers)[0].first; TF_AXIOM(csTime < adTime && adTime < bdTime && bdTime < cdTime); // Run a second time to test merging collector->SetEnabled(true); TestMarkerMacro(); collector->SetEnabled(false); reporter->ReportChromeTracing(std::cout); TraceEventTreeRefPtr timeline2 = reporter->GetEventTree(); const TraceEventTree::MarkerValuesMap& Markers2 = timeline2->GetMarkers(); size_t numSA = GetTimeOfMarker("Static Marker A", Markers2).size(); TF_AXIOM(numSA == 2); size_t numSB = GetTimeOfMarker("Static Marker B", Markers2).size(); TF_AXIOM(numSB == 2); size_t numSC = GetTimeOfMarker("Static Marker C", Markers2).size(); TF_AXIOM(numSC == 2); size_t numDA = GetTimeOfMarker("Dynamic Marker A", Markers2).size(); TF_AXIOM(numDA == 2); size_t numDB = GetTimeOfMarker("Dynamic Marker B", Markers2).size(); TF_AXIOM(numDB == 2); size_t numDC = GetTimeOfMarker("Dynamic Marker C", Markers2).size(); TF_AXIOM(numDC == 2); // Test clearing reporter->ClearTree(); collector->SetEnabled(true); TestMarkerMacro(); collector->SetEnabled(false); reporter->ReportChromeTracing(std::cout); TraceEventTreeRefPtr timeline3 = reporter->GetEventTree(); const TraceEventTree::MarkerValuesMap& Markers3 = timeline3->GetMarkers(); numSA = GetTimeOfMarker("Static Marker A", Markers3).size(); TF_AXIOM(numSA == 1); numSB = GetTimeOfMarker("Static Marker B", Markers3).size(); TF_AXIOM(numSB == 1); numSC = GetTimeOfMarker("Static Marker C", Markers3).size(); TF_AXIOM(numSC == 1); numDA = GetTimeOfMarker("Dynamic Marker A", Markers3).size(); TF_AXIOM(numDA == 1); numDB = GetTimeOfMarker("Dynamic Marker B", Markers3).size(); TF_AXIOM(numDB == 1); numDC = GetTimeOfMarker("Dynamic Marker C", Markers3).size(); TF_AXIOM(numDC == 1); }