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);
}
