Merge pull request #5185 from secondlife/marchcat/slua-linux

Update SLua editor with recent Linux branch changes

1 files changed, 0 insertions, 161 deletions

diff --git a/indra/llmath/tests/mathmisc_test.cpp b/indra/llmath/tests/mathmisc_test.cpp
index ff0899e975..810b0d80da 100644
--- a/indra/llmath/tests/mathmisc_test.cpp
+++ b/indra/llmath/tests/mathmisc_test.cpp
@@ -35,7 +35,6 @@
 
 #include "../llline.h"
 #include "../llmath.h"
-#include "../llsphere.h"
 #include "../v3math.h"
 
 namespace tut
@@ -280,166 +279,6 @@ namespace tut
 
 namespace tut
 {
-    struct sphere_data
-    {
-    };
-    typedef test_group<sphere_data> sphere_test;
-    typedef sphere_test::object sphere_object;
-    tut::sphere_test tsphere("LLSphere");
-
-    template<> template<>
-    void sphere_object::test<1>()
-    {
-        // test LLSphere::contains() and ::overlaps()
-        S32 number_of_tests = 10;
-        for (S32 test = 0; test < number_of_tests; ++test)
-        {
-            LLVector3 first_center(1.f, 1.f, 1.f);
-            F32 first_radius = 3.f;
-            LLSphere first_sphere( first_center, first_radius );
-
-            F32 half_millimeter = 0.0005f;
-            LLVector3 direction( ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
-            direction.normalize();
-
-            F32 distance = ll_frand(first_radius - 2.f * half_millimeter);
-            LLVector3 second_center = first_center + distance * direction;
-            F32 second_radius = first_radius - distance - half_millimeter;
-            LLSphere second_sphere( second_center, second_radius );
-            ensure("first sphere should contain the second", first_sphere.contains(second_sphere));
-            ensure("first sphere should overlap the second", first_sphere.overlaps(second_sphere));
-
-            distance = first_radius + ll_frand(first_radius);
-            second_center = first_center + distance * direction;
-            second_radius = distance - first_radius + half_millimeter;
-            second_sphere.set( second_center, second_radius );
-            ensure("first sphere should NOT contain the second", !first_sphere.contains(second_sphere));
-            ensure("first sphere should overlap the second", first_sphere.overlaps(second_sphere));
-
-            distance = first_radius + ll_frand(first_radius) + half_millimeter;
-            second_center = first_center + distance * direction;
-            second_radius = distance - first_radius - half_millimeter;
-            second_sphere.set( second_center, second_radius );
-            ensure("first sphere should NOT contain the second", !first_sphere.contains(second_sphere));
-            ensure("first sphere should NOT overlap the second", !first_sphere.overlaps(second_sphere));
-        }
-    }
-
-    template<> template<>
-    void sphere_object::test<2>()
-    {
-        skip("See SNOW-620.  Neither the test nor the code being tested seem good.  Also sim-only.");
-
-        // test LLSphere::getBoundingSphere()
-        S32 number_of_tests = 100;
-        S32 number_of_spheres = 10;
-        F32 sphere_center_range = 32.f;
-        F32 sphere_radius_range = 5.f;
-
-        for (S32 test = 0; test < number_of_tests; ++test)
-        {
-            // gegnerate a bunch of random sphere
-            std::vector< LLSphere > sphere_list;
-            for (S32 sphere_count=0; sphere_count < number_of_spheres; ++sphere_count)
-            {
-                LLVector3 direction( ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f, ll_frand(2.f) - 1.f);
-                direction.normalize();
-                F32 distance = ll_frand(sphere_center_range);
-                LLVector3 center = distance * direction;
-                F32 radius = ll_frand(sphere_radius_range);
-                LLSphere sphere( center, radius );
-                sphere_list.push_back(sphere);
-            }
-
-            // compute the bounding sphere
-            LLSphere bounding_sphere = LLSphere::getBoundingSphere(sphere_list);
-
-            // make sure all spheres are inside the bounding sphere
-            {
-                std::vector< LLSphere >::const_iterator sphere_itr;
-                for (sphere_itr = sphere_list.begin(); sphere_itr != sphere_list.end(); ++sphere_itr)
-                {
-                    ensure("sphere should be contained by the bounding sphere", bounding_sphere.contains(*sphere_itr));
-                }
-            }
-
-            // TODO -- improve LLSphere::getBoundingSphere() to the point where
-            // we can reduce the 'expansion' in the two tests below to about
-            // 2 mm or less
-
-            F32 expansion = 0.005f;
-            // move all spheres out a little bit
-            // and count how many are NOT contained
-            {
-                std::vector< LLVector3 > uncontained_directions;
-                std::vector< LLSphere >::iterator sphere_itr;
-                for (sphere_itr = sphere_list.begin(); sphere_itr != sphere_list.end(); ++sphere_itr)
-                {
-                    LLVector3 direction = sphere_itr->getCenter() - bounding_sphere.getCenter();
-                    direction.normalize();
-
-                    sphere_itr->setCenter( sphere_itr->getCenter() + expansion * direction );
-                    if (! bounding_sphere.contains( *sphere_itr ) )
-                    {
-                        uncontained_directions.push_back(direction);
-                    }
-                }
-                ensure("when moving spheres out there should be at least two uncontained spheres",
-                        uncontained_directions.size() > 1);
-
-                /* TODO -- when the bounding sphere algorithm is improved we can open up this test
-                 * at the moment it occasionally fails when the sphere collection is tight and small
-                 * (2 meters or less)
-                if (2 == uncontained_directions.size() )
-                {
-                    // if there were only two uncontained spheres then
-                    // the two directions should be nearly opposite
-                    F32 dir_dot = uncontained_directions[0] * uncontained_directions[1];
-                    ensure("two uncontained spheres should lie opposite the bounding center", dir_dot < -0.95f);
-                }
-                */
-            }
-
-            // compute the new bounding sphere
-            bounding_sphere = LLSphere::getBoundingSphere(sphere_list);
-
-            // increase the size of all spheres a little bit
-            // and count how many are NOT contained
-            {
-                std::vector< LLVector3 > uncontained_directions;
-                std::vector< LLSphere >::iterator sphere_itr;
-                for (sphere_itr = sphere_list.begin(); sphere_itr != sphere_list.end(); ++sphere_itr)
-                {
-                    LLVector3 direction = sphere_itr->getCenter() - bounding_sphere.getCenter();
-                    direction.normalize();
-
-                    sphere_itr->setRadius( sphere_itr->getRadius() + expansion );
-                    if (! bounding_sphere.contains( *sphere_itr ) )
-                    {
-                        uncontained_directions.push_back(direction);
-                    }
-                }
-                ensure("when boosting sphere radii there should be at least two uncontained spheres",
-                        uncontained_directions.size() > 1);
-
-                /* TODO -- when the bounding sphere algorithm is improved we can open up this test
-                 * at the moment it occasionally fails when the sphere collection is tight and small
-                 * (2 meters or less)
-                if (2 == uncontained_directions.size() )
-                {
-                    // if there were only two uncontained spheres then
-                    // the two directions should be nearly opposite
-                    F32 dir_dot = uncontained_directions[0] * uncontained_directions[1];
-                    ensure("two uncontained spheres should lie opposite the bounding center", dir_dot < -0.95f);
-                }
-                */
-            }
-        }
-    }
-}
-
-namespace tut
-{
     F32 SMALL_RADIUS = 1.0f;
     F32 MEDIUM_RADIUS = 5.0f;
     F32 LARGE_RADIUS = 10.0f;