diff options
Diffstat (limited to 'indra/llprimitive/tests')
| -rw-r--r-- | indra/llprimitive/tests/llgltfmaterial_test.cpp | 92 | ||||
| -rw-r--r-- | indra/llprimitive/tests/llmediaentry_test.cpp | 219 | ||||
| -rw-r--r-- | indra/llprimitive/tests/llmessagesystem_stub.cpp | 18 | ||||
| -rw-r--r-- | indra/llprimitive/tests/llprimitive_test.cpp | 376 |
4 files changed, 386 insertions, 319 deletions
diff --git a/indra/llprimitive/tests/llgltfmaterial_test.cpp b/indra/llprimitive/tests/llgltfmaterial_test.cpp index 88b6fae3a7..4f2de82386 100644 --- a/indra/llprimitive/tests/llgltfmaterial_test.cpp +++ b/indra/llprimitive/tests/llgltfmaterial_test.cpp @@ -1,31 +1,33 @@ -/** +/** * @file llgltfmaterial_test.cpp * - * $LicenseInfo:firstyear=2023&license=viewerlgpl$ + * $LicenseInfo:firstyear=2023&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2023, Linden Research, Inc. - * + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. - * + * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. - * + * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * + * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA - * $/LicenseInfo$ + * $/LicenseInfo$ */ #include "linden_common.h" #include "lltut.h" +#include <set> + #include "../llgltfmaterial.h" #include "lluuid.cpp" @@ -108,9 +110,9 @@ namespace tut material.setAlphaCutoff(test_fraction); // Because this is the default value, it should append to the extras field to mark it as an override - material.setAlphaMode(LLGLTFMaterial::ALPHA_MODE_OPAQUE); + material.setAlphaMode(LLGLTFMaterial::ALPHA_MODE_OPAQUE, true); // Because this is the default value, it should append to the extras field to mark it as an override - material.setDoubleSided(false); + material.setDoubleSided(false, true); return material; } @@ -143,7 +145,7 @@ namespace tut #if LL_WINDOWS // If any fields are added/changed, these tests should be updated (consider also updating ASSET_VERSION in LLGLTFMaterial) // This test result will vary between compilers, so only test a single platform - ensure_equals("fields supported for GLTF (sizeof check)", sizeof(LLGLTFMaterial), 216); + ensure_equals("fields supported for GLTF (sizeof check)", sizeof(LLGLTFMaterial), 232); #endif #endif ensure_equals("LLGLTFMaterial texture info count", (U32)LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT, 4); @@ -366,4 +368,74 @@ namespace tut ensure_equals("LLGLTFMaterial: double sided override flag unset", material.mOverrideDoubleSided, false); } } + + template<typename T> + void ensure_material_hash_pre(LLGLTFMaterial& material, T& material_field, const T new_value, const std::string& field_name) + { + ensure("LLGLTFMaterial: Hash: Test field " + field_name + " is part of the test material object", ( + size_t(&material_field) >= size_t(&material) && + (size_t(&material_field) + sizeof(material_field)) <= (size_t(&material) + sizeof(material)) + )); + ensure("LLGLTFMaterial: Hash: " + field_name + " differs and will cause a perturbation worth hashing", material_field != new_value); + } + + template<typename T> + void ensure_material_hash_not_changed(LLGLTFMaterial& material, T& material_field, const T new_value, const std::string& field_name) + { + ensure_material_hash_pre(material, material_field, new_value, field_name); + + const LLGLTFMaterial old_material = material; + material_field = new_value; + // If this test fails, consult LLGLTFMaterial::getHash, and optionally consult http://www.catb.org/esr/structure-packing/ for guidance on optimal memory packing (effectiveness is platform-dependent) + ensure_equals(("LLGLTFMaterial: Hash: Perturbing " + field_name + " to new value does NOT change the hash").c_str(), material.getHash(), old_material.getHash()); + } + + template<typename T> + void ensure_material_hash_changed(LLGLTFMaterial& material, T& material_field, const T new_value, const std::string& field_name) + { + ensure_material_hash_pre(material, material_field, new_value, field_name); + + const LLGLTFMaterial old_material = material; + material_field = new_value; + // If this test fails, consult LLGLTFMaterial::getHash, and optionally consult http://www.catb.org/esr/structure-packing/ for guidance on optimal memory packing (effectiveness is platform-dependent) + ensure_not_equals(("LLGLTFMaterial: Hash: Perturbing " + field_name + " to new value changes the hash").c_str(), material.getHash(), old_material.getHash()); + } + +#define ENSURE_HASH_NOT_CHANGED(HASH_MAT, SOURCE_MAT, FIELD) ensure_material_hash_not_changed(HASH_MAT, HASH_MAT.FIELD, SOURCE_MAT.FIELD, #FIELD) +#define ENSURE_HASH_CHANGED(HASH_MAT, SOURCE_MAT, FIELD) ensure_material_hash_changed(HASH_MAT, HASH_MAT.FIELD, SOURCE_MAT.FIELD, #FIELD) + + // Test LLGLTFMaterial::getHash, which is very sensitive to the ordering of fields + template<> template<> + void llgltfmaterial_object_t::test<12>() + { + // *NOTE: Due to direct manipulation of the fields of materials + // throughout this test, the resulting modified materials may not be + // compliant or properly serializable. + + // Ensure all fields of source_mat are set to values that differ from + // LLGLTFMaterial::sDefault, even if that would result in an invalid + // material object. + LLGLTFMaterial source_mat = create_test_material(); + source_mat.mTrackingIdToLocalTexture[LLUUID::generateNewID()] = LLUUID::generateNewID(); + source_mat.mLocalTexDataDigest = 1; + source_mat.mAlphaMode = LLGLTFMaterial::ALPHA_MODE_MASK; + source_mat.mDoubleSided = true; + + LLGLTFMaterial hash_mat; + + ENSURE_HASH_NOT_CHANGED(hash_mat, source_mat, mTrackingIdToLocalTexture); + ENSURE_HASH_CHANGED(hash_mat, source_mat, mLocalTexDataDigest); + + ENSURE_HASH_CHANGED(hash_mat, source_mat, mTextureId); + ENSURE_HASH_CHANGED(hash_mat, source_mat, mTextureTransform); + ENSURE_HASH_CHANGED(hash_mat, source_mat, mBaseColor); + ENSURE_HASH_CHANGED(hash_mat, source_mat, mEmissiveColor); + ENSURE_HASH_CHANGED(hash_mat, source_mat, mMetallicFactor); + ENSURE_HASH_CHANGED(hash_mat, source_mat, mRoughnessFactor); + ENSURE_HASH_CHANGED(hash_mat, source_mat, mAlphaCutoff); + ENSURE_HASH_CHANGED(hash_mat, source_mat, mAlphaMode); + ENSURE_HASH_CHANGED(hash_mat, source_mat, mDoubleSided); + ENSURE_HASH_CHANGED(hash_mat, source_mat, mOverrideDoubleSided); + ENSURE_HASH_CHANGED(hash_mat, source_mat, mOverrideAlphaMode); + } } diff --git a/indra/llprimitive/tests/llmediaentry_test.cpp b/indra/llprimitive/tests/llmediaentry_test.cpp index b072ce3964..414df66680 100644 --- a/indra/llprimitive/tests/llmediaentry_test.cpp +++ b/indra/llprimitive/tests/llmediaentry_test.cpp @@ -1,39 +1,34 @@ -/** +/** * @file llmediaentry_test.cpp * @brief llmediaentry unit tests * - * $LicenseInfo:firstyear=2001&license=viewerlgpl$ + * $LicenseInfo:firstyear=2001&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. - * + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. - * + * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. - * + * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * + * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA - * $/LicenseInfo$ + * $/LicenseInfo$ */ #include "linden_common.h" #include "lltut.h" -#if LL_WINDOWS -#pragma warning (push) -#pragma warning (disable : 4702) // boost::lexical_cast generates this warning -#endif + #include <boost/lexical_cast.hpp> -#if LL_WINDOWS -#pragma warning (pop) -#endif + #include "llstring.h" #include "llsdutil.h" #include "llsdserialize.h" @@ -154,7 +149,7 @@ namespace tut defaultMediaEntryStr = DEFAULT_MEDIA_ENTRY; std::istringstream d(DEFAULT_MEDIA_ENTRY); LLSDSerialize::fromXML(defaultMediaEntryLLSD, d); - } + } std::string emptyMediaEntryStr; LLSD emptyMediaEntryLLSD; std::string defaultMediaEntryStr; @@ -164,7 +159,7 @@ namespace tut typedef test_group<MediaEntry_test, 55> factory; typedef factory::object object; } - + namespace { @@ -211,7 +206,7 @@ namespace tut void whitelist_test(int num, bool enable, const char *whitelist, const char *candidate_url, bool expected_pass) { - std::string message = "Whitelist test " + boost::lexical_cast<std::string>(num); + std::string message = "Whitelist test " + std::to_string(num); LLMediaEntry entry; entry.setWhiteListEnable(enable); set_whitelist(entry, whitelist); @@ -237,18 +232,18 @@ namespace tut whitelist_test(num, true, whitelist, candidate_url, true); } - template<> template<> - void object::test<1>() - { - set_test_name("Test LLMediaEntry Instantiation"); - LLMediaEntry entry; + template<> template<> + void object::test<1>() + { + set_test_name("Test LLMediaEntry Instantiation"); + LLMediaEntry entry; ensure_llsd_equals(get_test_name() + " failed", defaultMediaEntryLLSD, entry.asLLSD()); - } + } - template<> template<> - void object::test<2>() - { - set_test_name("Test LLMediaEntry Instantiation from LLSD"); + template<> template<> + void object::test<2>() + { + set_test_name("Test LLMediaEntry Instantiation from LLSD"); LLMediaEntry entry; LLSD sd; entry.fromLLSD(sd); @@ -275,33 +270,33 @@ namespace tut set_test_name("Test LLMediaEntry::asLLSD()"); LLMediaEntry entry; LLSD sd; - // Put some cruft in the LLSD + // Put some cruft in the LLSD sd[LLMediaEntry::CURRENT_URL_KEY] = "http://www.example.com"; - LLSD whitelist; - whitelist.append("*.example.com"); + LLSD whitelist; + whitelist.append("*.example.com"); sd[LLMediaEntry::WHITELIST_KEY] = whitelist; entry.asLLSD(sd); ensure_llsd_equals(get_test_name() + " failed", defaultMediaEntryLLSD, sd); } - + template<> template<> void object::test<5>() { set_test_name("Test LLMediaEntry::asLLSD() -> LLMediaEntry::fromLLSD()"); LLMediaEntry entry1, entry2; - // Add a whitelist to entry2 - std::vector<std::string> whitelist; - whitelist.push_back("*.example.com"); + // Add a whitelist to entry2 + std::vector<std::string> whitelist; + whitelist.push_back("*.example.com"); entry2.setWhiteList(whitelist); - // Render entry1 (which has no whitelist) as an LLSD + // Render entry1 (which has no whitelist) as an LLSD LLSD sd; - entry1.asLLSD(sd); - // "read" that LLSD into entry 2 - entry2.fromLLSD(sd); + entry1.asLLSD(sd); + // "read" that LLSD into entry 2 + entry2.fromLLSD(sd); ensure_llsd_equals(get_test_name() + " failed", defaultMediaEntryLLSD, entry2.asLLSD()); } - + // limit tests const char *URL_OK = "http://www.example.com"; const char *URL_TOO_BIG = "http://www.example.com.qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq"; @@ -315,7 +310,7 @@ namespace tut ensure(get_test_name() + " ok failed", status == LSL_STATUS_OK); status = entry.setCurrentURL(URL_TOO_BIG); ensure(get_test_name() + " ok failed", status == LSL_STATUS_BOUNDS_ERROR); - } + } template<> template<> void object::test<7>() @@ -332,7 +327,7 @@ namespace tut void object::test<8>() { set_test_name("Test Limits on setting whitelist"); - + // Test a valid list LLMediaEntry entry; std::vector<std::string> whitelist; @@ -346,7 +341,7 @@ namespace tut void object::test<9>() { set_test_name("Test Limits on setting whitelist too big"); - + // Test an invalid list LLMediaEntry entry; std::vector<std::string> whitelist, empty; @@ -361,7 +356,7 @@ namespace tut void object::test<10>() { set_test_name("Test Limits on setting whitelist too many"); - + // Test an invalid list LLMediaEntry entry; std::vector<std::string> whitelist, empty; @@ -377,7 +372,7 @@ namespace tut void object::test<11>() { set_test_name("Test to make sure both setWhiteList() functions behave the same"); - + // Test a valid list std::vector<std::string> whitelist, empty; LLSD whitelist_llsd; @@ -387,10 +382,10 @@ namespace tut ensure(get_test_name() + " setWhiteList(s) don't match", entry1.setWhiteList(whitelist) == LSL_STATUS_OK && entry2.setWhiteList(whitelist_llsd)== LSL_STATUS_OK ); - ensure(get_test_name() + " failed", + ensure(get_test_name() + " failed", entry1.getWhiteList() == entry2.getWhiteList()); } - + template<> template<> void object::test<12>() { @@ -407,7 +402,7 @@ namespace tut ensure(get_test_name() + " setWhiteList(s) don't match", entry1.setWhiteList(whitelist) == LSL_STATUS_BOUNDS_ERROR && entry2.setWhiteList(whitelist_llsd) == LSL_STATUS_BOUNDS_ERROR); - ensure(get_test_name() + " failed", + ensure(get_test_name() + " failed", empty == entry1.getWhiteList() && empty == entry2.getWhiteList()); } @@ -425,78 +420,78 @@ namespace tut whitelist_llsd.append("Q"); } LLMediaEntry entry1, entry2; - ensure(get_test_name() + " invalid result", + ensure(get_test_name() + " invalid result", entry1.setWhiteList(whitelist) == LSL_STATUS_BOUNDS_ERROR && entry2.setWhiteList(whitelist_llsd) == LSL_STATUS_BOUNDS_ERROR); - ensure(get_test_name() + " failed", + ensure(get_test_name() + " failed", empty == entry1.getWhiteList() && empty == entry2.getWhiteList()); } - + template<> template<> - void object::test<14>() - { - // Whitelist check tests - int n=0; - - // Check the "empty whitelist" case - whitelist_test(++n, "", "http://www.example.com", true); - - // Check the "missing scheme" case - whitelist_test(++n, "www.example.com", "http://www.example.com", true); - - // Check the "exactly the same" case - whitelist_test(++n, "http://example.com", "http://example.com", true); - - // Check the enable flag - whitelist_test(++n, false, "www.example.com", "http://www.secondlife.com", true); - whitelist_test(++n, true, "www.example.com", "http://www.secondlife.com", false); - - // Check permutations of trailing slash: - whitelist_test(++n, "http://www.example.com", "http://www.example.com/", true); - whitelist_test(++n, "http://www.example.com/", "http://www.example.com/", true); - whitelist_test(++n, "http://www.example.com/", "http://www.example.com", false); - whitelist_test(++n, "http://www.example.com", "http://www.example.com/foobar", true); - whitelist_test(++n, "http://www.example.com/", "http://www.example.com/foobar", false); - - - // More cases... - whitelist_test(++n, "http://example.com", "http://example.com/wiki", true); - whitelist_test(++n, "www.example.com", "http://www.example.com/help", true); - whitelist_test(++n, "http://www.example.com", "http://wwwexample.com", false); - whitelist_test(++n, "http://www.example.com", "http://www.example.com/wiki", true); - whitelist_test(++n, "example.com", "http://wwwexample.com", false); - whitelist_test(++n, "http://www.example.com/", "http://www.amazon.com/wiki", false); - whitelist_test(++n, "www.example.com", "http://www.amazon.com", false); - - // regexp cases - whitelist_test(++n, "*.example.com", "http://www.example.com", true); - whitelist_test(++n, "*.example.com", "http://www.amazon.com", false); - whitelist_test(++n, "*.example.com", "http://www.example.com/foo/bar", true); - whitelist_test(++n, "*.example.com", "http:/example.com/foo/bar", false); - whitelist_test(++n, "*example.com", "http://example.com/foo/bar", true); - whitelist_test(++n, "*example.com", "http://my.virus.com/foo/bar?example.com", false); - whitelist_test(++n, "example.com", "http://my.virus.com/foo/bar?example.com", false); - whitelist_test(++n, "*example.com", "http://my.virus.com/foo/bar?*example.com", false); - whitelist_test(++n, "http://*example.com", "http://www.example.com", true); - whitelist_test(++n, "http://*.example.com", "http://www.example.com", true); - whitelist_test(++n, "http://*.e$?^.com", "http://www.e$?^.com", true); - whitelist_test(++n, "*.example.com/foo/bar", "http://www.example.com/", false); - whitelist_test(++n, "*.example.com/foo/bar", "http://example.com/foo/bar", false); - whitelist_test(++n, "http://*.example.com/foo/bar", "http://www.example.com", false); - whitelist_test(++n, "http://*.example.com", "https://www.example.com", false); - whitelist_test(++n, "http*://*.example.com", "rtsp://www.example.com", false); - whitelist_test(++n, "http*://*.example.com", "https://www.example.com", true); - whitelist_test(++n, "example.com", "http://www.example.com", false); - whitelist_test(++n, "www.example.com", "http://www.example.com:80", false); - whitelist_test(++n, "www.example.com", "http://www.example.com", true); - whitelist_test(++n, "www.example.com/", "http://www.example.com", false); - whitelist_test(++n, "www.example.com/foo/bar/*", "http://www.example.com/foo/bar/baz", true); + void object::test<14>() + { + // Whitelist check tests + int n=0; + + // Check the "empty whitelist" case + whitelist_test(++n, "", "http://www.example.com", true); + + // Check the "missing scheme" case + whitelist_test(++n, "www.example.com", "http://www.example.com", true); + + // Check the "exactly the same" case + whitelist_test(++n, "http://example.com", "http://example.com", true); + + // Check the enable flag + whitelist_test(++n, false, "www.example.com", "http://www.secondlife.com", true); + whitelist_test(++n, true, "www.example.com", "http://www.secondlife.com", false); + + // Check permutations of trailing slash: + whitelist_test(++n, "http://www.example.com", "http://www.example.com/", true); + whitelist_test(++n, "http://www.example.com/", "http://www.example.com/", true); + whitelist_test(++n, "http://www.example.com/", "http://www.example.com", false); + whitelist_test(++n, "http://www.example.com", "http://www.example.com/foobar", true); + whitelist_test(++n, "http://www.example.com/", "http://www.example.com/foobar", false); + + + // More cases... + whitelist_test(++n, "http://example.com", "http://example.com/wiki", true); + whitelist_test(++n, "www.example.com", "http://www.example.com/help", true); + whitelist_test(++n, "http://www.example.com", "http://wwwexample.com", false); + whitelist_test(++n, "http://www.example.com", "http://www.example.com/wiki", true); + whitelist_test(++n, "example.com", "http://wwwexample.com", false); + whitelist_test(++n, "http://www.example.com/", "http://www.amazon.com/wiki", false); + whitelist_test(++n, "www.example.com", "http://www.amazon.com", false); + + // regexp cases + whitelist_test(++n, "*.example.com", "http://www.example.com", true); + whitelist_test(++n, "*.example.com", "http://www.amazon.com", false); + whitelist_test(++n, "*.example.com", "http://www.example.com/foo/bar", true); + whitelist_test(++n, "*.example.com", "http:/example.com/foo/bar", false); + whitelist_test(++n, "*example.com", "http://example.com/foo/bar", true); + whitelist_test(++n, "*example.com", "http://my.virus.com/foo/bar?example.com", false); + whitelist_test(++n, "example.com", "http://my.virus.com/foo/bar?example.com", false); + whitelist_test(++n, "*example.com", "http://my.virus.com/foo/bar?*example.com", false); + whitelist_test(++n, "http://*example.com", "http://www.example.com", true); + whitelist_test(++n, "http://*.example.com", "http://www.example.com", true); + whitelist_test(++n, "http://*.e$?^.com", "http://www.e$?^.com", true); + whitelist_test(++n, "*.example.com/foo/bar", "http://www.example.com/", false); + whitelist_test(++n, "*.example.com/foo/bar", "http://example.com/foo/bar", false); + whitelist_test(++n, "http://*.example.com/foo/bar", "http://www.example.com", false); + whitelist_test(++n, "http://*.example.com", "https://www.example.com", false); + whitelist_test(++n, "http*://*.example.com", "rtsp://www.example.com", false); + whitelist_test(++n, "http*://*.example.com", "https://www.example.com", true); + whitelist_test(++n, "example.com", "http://www.example.com", false); + whitelist_test(++n, "www.example.com", "http://www.example.com:80", false); + whitelist_test(++n, "www.example.com", "http://www.example.com", true); + whitelist_test(++n, "www.example.com/", "http://www.example.com", false); + whitelist_test(++n, "www.example.com/foo/bar/*", "http://www.example.com/foo/bar/baz", true); // Path only - whitelist_test(++n, "/foo/*/baz", "http://www.example.com/foo/bar/baz", true); - whitelist_test(++n, "/foo/*/baz", "http://www.example.com/foo/bar/", false); - } - + whitelist_test(++n, "/foo/*/baz", "http://www.example.com/foo/bar/baz", true); + whitelist_test(++n, "/foo/*/baz", "http://www.example.com/foo/bar/", false); + } + } diff --git a/indra/llprimitive/tests/llmessagesystem_stub.cpp b/indra/llprimitive/tests/llmessagesystem_stub.cpp index 9006833054..531a8b069d 100644 --- a/indra/llprimitive/tests/llmessagesystem_stub.cpp +++ b/indra/llprimitive/tests/llmessagesystem_stub.cpp @@ -1,26 +1,26 @@ -/** +/** * @file llmessagesystem_stub.cpp * - * $LicenseInfo:firstyear=2008&license=viewerlgpl$ + * $LicenseInfo:firstyear=2008&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. - * + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. - * + * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. - * + * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * + * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA - * $/LicenseInfo$ + * $/LicenseInfo$ */ #include "linden_common.h" @@ -29,12 +29,12 @@ const char * const _PREHASH_TextureEntry = "TextureEntry"; S32 LLMessageSystem::getSizeFast(char const*, char const*) const { - return 0; + return 0; } S32 LLMessageSystem::getSizeFast(char const*, int, char const*) const { - return 0; + return 0; } void LLMessageSystem::getBinaryDataFast(char const*, char const*, void*, int, int, int) diff --git a/indra/llprimitive/tests/llprimitive_test.cpp b/indra/llprimitive/tests/llprimitive_test.cpp index 0ff0795fdc..0213a3e8b6 100644 --- a/indra/llprimitive/tests/llprimitive_test.cpp +++ b/indra/llprimitive/tests/llprimitive_test.cpp @@ -1,25 +1,25 @@ -/** +/** * @file llprimitive_test.cpp * @brief llprimitive tests * * $LicenseInfo:firstyear=2001&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. - * + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. - * + * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. - * + * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * + * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ @@ -35,40 +35,40 @@ class DummyVolumeMgr : public LLVolumeMgr { public: - DummyVolumeMgr() : LLVolumeMgr(), mVolumeTest(NULL), mCurrDetailTest(0) {} - ~DummyVolumeMgr() - { - } - - - virtual LLVolume *refVolume(const LLVolumeParams &volume_params, const S32 detail) - { - if (mVolumeTest.isNull() || volume_params != mCurrParamsTest || detail != mCurrDetailTest) - { - F32 volume_detail = LLVolumeLODGroup::getVolumeScaleFromDetail(detail); - mVolumeTest = new LLVolume(volume_params, volume_detail, FALSE, FALSE); - mCurrParamsTest = volume_params; - mCurrDetailTest = detail; - return mVolumeTest; - } - else - { - return mVolumeTest; - } - } - - virtual void unrefVolume(LLVolume *volumep) - { - if (mVolumeTest == volumep) - { - mVolumeTest = NULL; - } - } - + DummyVolumeMgr() : LLVolumeMgr(), mVolumeTest(NULL), mCurrDetailTest(0) {} + ~DummyVolumeMgr() + { + } + + + virtual LLVolume *refVolume(const LLVolumeParams &volume_params, const S32 detail) + { + if (mVolumeTest.isNull() || volume_params != mCurrParamsTest || detail != mCurrDetailTest) + { + F32 volume_detail = LLVolumeLODGroup::getVolumeScaleFromDetail(detail); + mVolumeTest = new LLVolume(volume_params, volume_detail, false, false); + mCurrParamsTest = volume_params; + mCurrDetailTest = detail; + return mVolumeTest; + } + else + { + return mVolumeTest; + } + } + + virtual void unrefVolume(LLVolume *volumep) + { + if (mVolumeTest == volumep) + { + mVolumeTest = NULL; + } + } + private: - LLPointer<LLVolume> mVolumeTest; - LLVolumeParams mCurrParamsTest; - S32 mCurrDetailTest; + LLPointer<LLVolume> mVolumeTest; + LLVolumeParams mCurrParamsTest; + S32 mCurrDetailTest; }; LLMaterialID::LLMaterialID() {} @@ -109,163 +109,163 @@ void LLPrimTextureList::take(LLPrimTextureList &other_list) { } void LLPrimTextureList::setSize(S32 new_size) { mEntryList.resize(new_size); } void LLPrimTextureList::setAllIDs(const LLUUID &id) { } LLTextureEntry * LLPrimTextureList::getTexture(const U8 index) const { return nullptr; } -S32 LLPrimTextureList::size() const { return mEntryList.size(); } +S32 LLPrimTextureList::size() const { return static_cast<S32>(mEntryList.size()); } class PRIMITIVE_TEST_SETUP { public: - PRIMITIVE_TEST_SETUP() - { - volume_manager_test = new DummyVolumeMgr(); - LLPrimitive::setVolumeManager(volume_manager_test); - } - - ~PRIMITIVE_TEST_SETUP() - { - LLPrimitive::cleanupVolumeManager(); - } - DummyVolumeMgr * volume_manager_test; -}; + PRIMITIVE_TEST_SETUP() + { + volume_manager_test = new DummyVolumeMgr(); + LLPrimitive::setVolumeManager(volume_manager_test); + } + + ~PRIMITIVE_TEST_SETUP() + { + LLPrimitive::cleanupVolumeManager(); + } + DummyVolumeMgr * volume_manager_test; +}; namespace tut { - struct llprimitive - { - PRIMITIVE_TEST_SETUP setup_class; - }; - - typedef test_group<llprimitive> llprimitive_t; - typedef llprimitive_t::object llprimitive_object_t; - tut::llprimitive_t tut_llprimitive("LLPrimitive"); - - template<> template<> - void llprimitive_object_t::test<1>() - { - set_test_name("Test LLPrimitive Instantiation"); - LLPrimitive test; - } - - template<> template<> - void llprimitive_object_t::test<2>() - { - set_test_name("Test LLPrimitive PCode setter and getter."); - LLPrimitive test; - ensure_equals(test.getPCode(), 0); - LLPCode code = 1; - test.setPCode(code); - ensure_equals(test.getPCode(), code); - } - - template<> template<> - void llprimitive_object_t::test<3>() - { - set_test_name("Test llprimitive constructor and initer."); - LLPCode code = 1; - LLPrimitive primitive; - primitive.init_primitive(code); - ensure_equals(primitive.getPCode(), code); - } - - template<> template<> - void llprimitive_object_t::test<4>() - { - set_test_name("Test Static llprimitive constructor and initer."); - LLPCode code = 1; - LLPrimitive * primitive = LLPrimitive::createPrimitive(code); - ensure(primitive != NULL); - ensure_equals(primitive->getPCode(), code); - } - - template<> template<> - void llprimitive_object_t::test<5>() - { - set_test_name("Test setVolume creation of new unique volume."); - LLPrimitive primitive; - LLVolumeParams params; - - // Make sure volume starts off null - ensure(primitive.getVolume() == NULL); - - // Make sure we have no texture entries before setting the volume - ensure_equals(primitive.getNumTEs(), 0); - - // Test that GEOMETRY has not been flagged as changed. - ensure(!primitive.isChanged(LLXform::GEOMETRY)); - - // Make sure setVolume returns true - ensure(primitive.setVolume(params, 0, true) == TRUE); - LLVolume* new_volume = primitive.getVolume(); - - // make sure new volume was actually created - ensure(new_volume != NULL); - - // Make sure that now that we've set the volume we have texture entries - ensure_not_equals(primitive.getNumTEs(), 0); - - // Make sure that the number of texture entries equals the number of faces in the volume (should be 6) - ensure_equals(new_volume->getNumFaces(), 6); - ensure_equals(primitive.getNumTEs(), new_volume->getNumFaces()); - - // Test that GEOMETRY has been flagged as changed. - ensure(primitive.isChanged(LLXform::GEOMETRY)); - - // Run it twice to make sure it doesn't create a different one if params are the same - ensure(primitive.setVolume(params, 0, true) == FALSE); - ensure(new_volume == primitive.getVolume()); - - // Change the param definition and try setting it again. - params.setRevolutions(4); - ensure(primitive.setVolume(params, 0, true) == TRUE); - - // Ensure that we now have a different volume - ensure(new_volume != primitive.getVolume()); - } - - template<> template<> - void llprimitive_object_t::test<6>() - { - set_test_name("Test setVolume creation of new NOT-unique volume."); - LLPrimitive primitive; - LLVolumeParams params; - - // Make sure volume starts off null - ensure(primitive.getVolume() == NULL); - - // Make sure we have no texture entries before setting the volume - ensure_equals(primitive.getNumTEs(), 0); - - // Test that GEOMETRY has not been flagged as changed. - ensure(!primitive.isChanged(LLXform::GEOMETRY)); - - // Make sure setVolume returns true - ensure(primitive.setVolume(params, 0, false) == TRUE); - - LLVolume* new_volume = primitive.getVolume(); - - // make sure new volume was actually created - ensure(new_volume != NULL); - - // Make sure that now that we've set the volume we have texture entries - ensure_not_equals(primitive.getNumTEs(), 0); - - // Make sure that the number of texture entries equals the number of faces in the volume (should be 6) - ensure_equals(new_volume->getNumFaces(), 6); - ensure_equals(primitive.getNumTEs(), new_volume->getNumFaces()); - - // Test that GEOMETRY has been flagged as changed. - ensure(primitive.isChanged(LLXform::GEOMETRY)); - - // Run it twice to make sure it doesn't create a different one if params are the same - ensure(primitive.setVolume(params, 0, false) == FALSE); - ensure(new_volume == primitive.getVolume()); - - // Change the param definition and try setting it again. - params.setRevolutions(4); - ensure(primitive.setVolume(params, 0, false) == TRUE); - - // Ensure that we now have a different volume - ensure(new_volume != primitive.getVolume()); - } + struct llprimitive + { + PRIMITIVE_TEST_SETUP setup_class; + }; + + typedef test_group<llprimitive> llprimitive_t; + typedef llprimitive_t::object llprimitive_object_t; + tut::llprimitive_t tut_llprimitive("LLPrimitive"); + + template<> template<> + void llprimitive_object_t::test<1>() + { + set_test_name("Test LLPrimitive Instantiation"); + LLPrimitive test; + } + + template<> template<> + void llprimitive_object_t::test<2>() + { + set_test_name("Test LLPrimitive PCode setter and getter."); + LLPrimitive test; + ensure_equals(test.getPCode(), 0); + LLPCode code = 1; + test.setPCode(code); + ensure_equals(test.getPCode(), code); + } + + template<> template<> + void llprimitive_object_t::test<3>() + { + set_test_name("Test llprimitive constructor and initer."); + LLPCode code = 1; + LLPrimitive primitive; + primitive.init_primitive(code); + ensure_equals(primitive.getPCode(), code); + } + + template<> template<> + void llprimitive_object_t::test<4>() + { + set_test_name("Test Static llprimitive constructor and initer."); + LLPCode code = 1; + LLPrimitive * primitive = LLPrimitive::createPrimitive(code); + ensure(primitive != NULL); + ensure_equals(primitive->getPCode(), code); + } + + template<> template<> + void llprimitive_object_t::test<5>() + { + set_test_name("Test setVolume creation of new unique volume."); + LLPrimitive primitive; + LLVolumeParams params; + + // Make sure volume starts off null + ensure(primitive.getVolume() == NULL); + + // Make sure we have no texture entries before setting the volume + ensure_equals(primitive.getNumTEs(), 0); + + // Test that GEOMETRY has not been flagged as changed. + ensure(!primitive.isChanged(LLXform::GEOMETRY)); + + // Make sure setVolume returns true + ensure(primitive.setVolume(params, 0, true) == true); + LLVolume* new_volume = primitive.getVolume(); + + // make sure new volume was actually created + ensure(new_volume != NULL); + + // Make sure that now that we've set the volume we have texture entries + ensure_not_equals(primitive.getNumTEs(), 0); + + // Make sure that the number of texture entries equals the number of faces in the volume (should be 6) + ensure_equals(new_volume->getNumFaces(), 6); + ensure_equals(primitive.getNumTEs(), new_volume->getNumFaces()); + + // Test that GEOMETRY has been flagged as changed. + ensure(primitive.isChanged(LLXform::GEOMETRY)); + + // Run it twice to make sure it doesn't create a different one if params are the same + ensure(primitive.setVolume(params, 0, true) == false); + ensure(new_volume == primitive.getVolume()); + + // Change the param definition and try setting it again. + params.setRevolutions(4); + ensure(primitive.setVolume(params, 0, true) == true); + + // Ensure that we now have a different volume + ensure(new_volume != primitive.getVolume()); + } + + template<> template<> + void llprimitive_object_t::test<6>() + { + set_test_name("Test setVolume creation of new NOT-unique volume."); + LLPrimitive primitive; + LLVolumeParams params; + + // Make sure volume starts off null + ensure(primitive.getVolume() == NULL); + + // Make sure we have no texture entries before setting the volume + ensure_equals(primitive.getNumTEs(), 0); + + // Test that GEOMETRY has not been flagged as changed. + ensure(!primitive.isChanged(LLXform::GEOMETRY)); + + // Make sure setVolume returns true + ensure(primitive.setVolume(params, 0, false) == true); + + LLVolume* new_volume = primitive.getVolume(); + + // make sure new volume was actually created + ensure(new_volume != NULL); + + // Make sure that now that we've set the volume we have texture entries + ensure_not_equals(primitive.getNumTEs(), 0); + + // Make sure that the number of texture entries equals the number of faces in the volume (should be 6) + ensure_equals(new_volume->getNumFaces(), 6); + ensure_equals(primitive.getNumTEs(), new_volume->getNumFaces()); + + // Test that GEOMETRY has been flagged as changed. + ensure(primitive.isChanged(LLXform::GEOMETRY)); + + // Run it twice to make sure it doesn't create a different one if params are the same + ensure(primitive.setVolume(params, 0, false) == false); + ensure(new_volume == primitive.getVolume()); + + // Change the param definition and try setting it again. + params.setRevolutions(4); + ensure(primitive.setVolume(params, 0, false) == true); + + // Ensure that we now have a different volume + ensure(new_volume != primitive.getVolume()); + } } #include "llmessagesystem_stub.cpp" |