static void testValueHash() { static_assert(VtIsHashable<int>(), ""); static_assert(!VtIsHashable<_Unhashable>(), ""); VtValue vHashable{1}; VtValue vUnhashable{_Unhashable{}}; // Test the dynamic hashability check. TF_AXIOM(vHashable.CanHash()); TF_AXIOM(!vUnhashable.CanHash()); { // Test that hashable types can hash without error. TfErrorMark m; vHashable.GetHash(); TF_AXIOM(m.IsClean()); } { // Test that unhashable types post an error when attempting to hash. TfErrorMark m; vUnhashable.GetHash(); TF_AXIOM(!m.IsClean()); m.Clear(); } }
static unsigned int _TestSetenvNoInit() { // Test that calling TfSetenv/TfUnsetenv without Python initialized still // sets/unsets the value into the process environment. unsigned int numErrors = 0; const string envName = "TEST_ENV_NAME"; const string envVal = "TestSetenvNoInit"; #ifdef PXR_PYTHON_SUPPORT_ENABLED if (TfPyIsInitialized()) { numErrors += 1; printf("ERROR: Python should not yet be initialized.\n"); return numErrors; } #endif // PXR_PYTHON_SUPPORT_ENABLED { TfErrorMark m; if (!TfSetenv(envName, envVal)) { numErrors += 1; printf("ERROR: Setenv failed\n"); } // Depend on the Tf error system to ouput any error messages. size_t n = 0; m.GetBegin(&n); numErrors += n; m.Clear(); } #ifdef PXR_PYTHON_SUPPORT_ENABLED if (TfPyIsInitialized()) { numErrors += 1; printf("ERROR: Python should not yet be initialized.\n"); } #endif // PXR_PYTHON_SUPPORT_ENABLED numErrors += _CheckResultInEnv(envName, envVal); if (!TfUnsetenv(envName)) { numErrors += 1; printf("ERROR: Unsetenv failed\n"); } numErrors += _CheckResultInEnv(envName, ""); return numErrors; }
static unsigned int _TestPySetenvNoInit() { // Test that calling TfPySetenv causes an error. unsigned int numErrors = 0; const string envName = "PY_TEST_ENV_NAME"; const string envVal = "TestPySetenvNoInit"; if (TfPyIsInitialized()) { numErrors += 1; printf("ERROR: Python should not yet be initialized.\n"); return numErrors; } { TfErrorMark m; fprintf(stderr, "===== Expected Error =====\n"); bool didSet = TfPySetenv(envName, envVal); fprintf(stderr, "=== End Expected Error ===\n"); if (didSet) { numErrors += 1; printf("ERROR: Calling TfPySetenv with uninitialized Python " "should return false."); } if (m.IsClean()) { numErrors += 1; printf("ERROR: Calling TfPySetenv with uninitialized Python " "should produce an error."); } m.Clear(); } if (TfPyIsInitialized()) { numErrors += 1; printf("ERROR: Python should not yet be initialized.\n"); return numErrors; } numErrors += _CheckResultInEnv(envName, ""); return numErrors; }
static bool Test_TfErrorThreadTransport() { TfErrorTransport transport; printf("Creating TfErrorMark\n"); TfErrorMark m; printf("Launching thread\n"); tbb::tbb_thread t(boost::bind(_ThreadTask, &transport)); TF_AXIOM(m.IsClean()); t.join(); printf("Thread completed, posting error.\n"); TF_AXIOM(m.IsClean()); transport.Post(); TF_AXIOM(not m.IsClean()); m.Clear(); return true; }
static bool Test_TfType_MultipleInheritance() { // Test TfType::GetAncestorTypes()'s error condition of // inconsistent multiple inheritance. (We'd ideally test this from // Python, but Python prohibits you from even declaring hierarchies // like this to begin with.) TfErrorMark m; m.SetMark(); vector<TfType> types; TF_AXIOM(m.IsClean()); TfType::Find<Z>().GetAllAncestorTypes(&types); TF_AXIOM(!m.IsClean()); m.Clear(); return true; }
static bool Test_TfError() { TfErrorMark m; size_t lineNum; m.SetMark(); TF_AXIOM(m.IsClean()); m.SetMark(); TF_ERROR(SMALL, "small error"); lineNum = __LINE__ - 1; TF_AXIOM(!m.IsClean()); TfErrorMark::Iterator i = m.GetBegin(); TF_AXIOM(i == TfDiagnosticMgr::GetInstance().GetErrorBegin()); TfError e = *i; TF_AXIOM(e.GetSourceFileName() == BUILD_COMPONENT_SRC_PREFIX __FILE__); TF_AXIOM(e.GetSourceLineNumber() == lineNum); TF_AXIOM(e.GetCommentary() == "small error"); TF_AXIOM(e.GetErrorCode() == SMALL); TF_AXIOM(e.GetErrorCodeAsString() == "SMALL"); TF_AXIOM(e.GetInfo<int>() == NULL); e.AugmentCommentary("augment"); TF_AXIOM(e.GetCommentary() == "small error\naugment"); i = TfDiagnosticMgr::GetInstance().EraseError(i); TF_AXIOM(i == TfDiagnosticMgr::GetInstance().GetErrorEnd()); m.SetMark(); TF_ERROR(1, MEDIUM, "medium error"); TF_ERROR(2, LARGE, "large error"); i = m.GetBegin(); TF_AXIOM(i == TfDiagnosticMgr::GetInstance().GetErrorBegin()); e = *i; TF_AXIOM(e.GetErrorCode() == MEDIUM); TF_AXIOM(*e.GetInfo<int>() == 1); ++i; TF_AXIOM(i != TfDiagnosticMgr::GetInstance().GetErrorEnd()); e = *i; TF_AXIOM(e.GetErrorCode() == LARGE); TF_AXIOM(*e.GetInfo<int>() == 2); m.Clear(); TF_AXIOM(m.IsClean()); TF_VERIFY(m.IsClean()); TF_AXIOM(TF_VERIFY(m.IsClean())); TF_CODING_ERROR("test error"); // It should be the case that m is not clean. TF_AXIOM(TF_VERIFY(not m.IsClean())); // It should not be the case that m is clean. TF_AXIOM(not TF_VERIFY(m.IsClean())); TF_AXIOM(not TF_VERIFY(m.IsClean(), "With a %s", "message.")); // Should issue a failed expect error. TF_VERIFY(m.IsClean()); m.Clear(); // Arbitrary info. std::string info("String containing arbitrary information."); // Issue a few different variations of errors. m.SetMark(); string errString = "Error!"; TF_CODING_ERROR("Coding error"); TF_CODING_ERROR("Coding error %d", 1); TF_CODING_ERROR(errString); TF_RUNTIME_ERROR("Runtime error"); TF_RUNTIME_ERROR("Runtime error %d", 1); TF_RUNTIME_ERROR(errString); TF_ERROR(SMALL, "const char *"); TF_ERROR(SMALL, "const char *, %s", "..."); TF_ERROR(SMALL, errString); TF_ERROR(info, MEDIUM, "const char *"); TF_ERROR(info, MEDIUM, "const char *, %s", "..."); TF_ERROR(info, MEDIUM, errString); TF_AXIOM(not m.IsClean()); m.Clear(); // Issue a few different warnings. string warningString = "Warning!"; TF_WARN("const char *"); TF_WARN("const char *, %s", "..."); TF_WARN(warningString); TF_WARN(SMALL, "const char *"); TF_WARN(SMALL, "const char *, %s", "..."); TF_WARN(SMALL, warningString); TF_WARN(info, MEDIUM, "const char *"); TF_WARN(info, MEDIUM, "const char *, %s", "..."); TF_WARN(info, MEDIUM, warningString); // Issue a few different status messages. string statusString = "Status"; TF_STATUS("const char *"); TF_STATUS("const char *, %s", "..."); TF_STATUS(statusString); TF_STATUS(SMALL, "const char *"); TF_STATUS(SMALL, "const char *, %s", "..."); TF_STATUS(SMALL, statusString); TF_STATUS(info, MEDIUM, "const char *"); TF_STATUS(info, MEDIUM, "const char *, %s", "..."); TF_STATUS(info, MEDIUM, statusString); return true; }