Skip to content
Snippets Groups Projects
Commit abbf5ff4 authored by AndreyL ProductEngine's avatar AndreyL ProductEngine
Browse files

Merged in lindenlab/viewer-lynx

parents b5f861ae b6dc7557
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 134 additions and 326 deletions
indra/llcorehttp/tests/test_llcorehttp_peer.py
+ 21
− 14
View file @ abbf5ff4
......@@ -34,16 +34,19 @@
import time
import select
import getopt
from threading import Thread
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
from SocketServer import ThreadingMixIn
from llbase.fastest_elementtree import parse as xml_parse
from llbase import llsd
# we're in llcorehttp/tests ; testrunner.py is found in llmessage/tests
sys.path.append(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir,
"llmessage", "tests"))
from testrunner import freeport, run, debug, VERBOSE
class TestHTTPRequestHandler(BaseHTTPRequestHandler):
......@@ -269,7 +272,7 @@ def log_error(self, format, *args):
# Suppress error output as well
pass
class Server(ThreadingMixIn, HTTPServer):
class Server(HTTPServer):
# This pernicious flag is on by default in HTTPServer. But proper
# operation of freeport() absolutely depends on it being off.
allow_reuse_address = False
......@@ -293,22 +296,26 @@ def handle_error(self, request, client_address):
if option == "-V" or option == "--valgrind":
do_valgrind = True
# Instantiate a Server(TestHTTPRequestHandler) on the first free port
# in the specified port range. Doing this inline is better than in a
# daemon thread: if it blows up here, we'll get a traceback. If it blew up
# in some other thread, the traceback would get eaten and we'd run the
# subject test program anyway.
httpd, port = freeport(xrange(8000, 8020),
lambda port: Server(('127.0.0.1', port), TestHTTPRequestHandler))
# function to make a server with specified port
make_server = lambda port: Server(('127.0.0.1', port), TestHTTPRequestHandler)
if not sys.platform.startswith("win"):
# Instantiate a Server(TestHTTPRequestHandler) on a port chosen by the
# runtime.
httpd = make_server(0)
else:
# "Then there's Windows"
# Instantiate a Server(TestHTTPRequestHandler) on the first free port
# in the specified port range.
httpd, port = freeport(xrange(8000, 8020), make_server)
# Pass the selected port number to the subject test program via the
# environment. We don't want to impose requirements on the test program's
# command-line parsing -- and anyway, for C++ integration tests, that's
# performed in TUT code rather than our own.
os.environ["LL_TEST_PORT"] = str(port)
debug("$LL_TEST_PORT = %s", port)
os.environ["LL_TEST_PORT"] = str(httpd.server_port)
debug("$LL_TEST_PORT = %s", httpd.server_port)
if do_valgrind:
args = ["valgrind", "--log-file=./valgrind.log"] + args
path_search = True
sys.exit(run(server=Thread(name="httpd", target=httpd.serve_forever), use_path=path_search, *args))
sys.exit(run(server_inst=httpd, use_path=path_search, *args))
indra/llcorehttp/tests/testrunner.py deleted 100755 → 0
+ 0
− 265
View file @ b5f861ae
#!/usr/bin/env python
"""\
@file testrunner.py
@author Nat Goodspeed
@date 2009-03-20
@brief Utilities for writing wrapper scripts for ADD_COMM_BUILD_TEST unit tests
$LicenseInfo:firstyear=2009&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$
"""
from __future__ import with_statement
import os
import sys
import re
import errno
import socket
VERBOSE = os.environ.get("INTEGRATION_TEST_VERBOSE", "0") # default to quiet
# Support usage such as INTEGRATION_TEST_VERBOSE=off -- distressing to user if
# that construct actually turns on verbosity...
VERBOSE = not re.match(r"(0|off|false|quiet)$", VERBOSE, re.IGNORECASE)
if VERBOSE:
def debug(fmt, *args):
print fmt % args
sys.stdout.flush()
else:
debug = lambda *args: None
def freeport(portlist, expr):
"""
Find a free server port to use. Specifically, evaluate 'expr' (a
callable(port)) until it stops raising EADDRINUSE exception.
Pass:
portlist: an iterable (e.g. xrange()) of ports to try. If you exhaust the
range, freeport() lets the socket.error exception propagate. If you want
unbounded, you could pass itertools.count(baseport), though of course in
practice the ceiling is 2^16-1 anyway. But it seems prudent to constrain
the range much more sharply: if we're iterating an absurd number of times,
probably something else is wrong.
expr: a callable accepting a port number, specifically one of the items
from portlist. If calling that callable raises socket.error with
EADDRINUSE, freeport() retrieves the next item from portlist and retries.
Returns: (expr(port), port)
port: the value from portlist for which expr(port) succeeded
Raises:
Any exception raised by expr(port) other than EADDRINUSE.
socket.error if, for every item from portlist, expr(port) raises
socket.error. The exception you see is the one from the last item in
portlist.
StopIteration if portlist is completely empty.
Example:
class Server(HTTPServer):
# If you use BaseHTTPServer.HTTPServer, turning off this flag is
# essential for proper operation of freeport()!
allow_reuse_address = False
# ...
server, port = freeport(xrange(8000, 8010),
lambda port: Server(("localhost", port),
MyRequestHandler))
# pass 'port' to client code
# call server.serve_forever()
"""
try:
# If portlist is completely empty, let StopIteration propagate: that's an
# error because we can't return meaningful values. We have no 'port',
# therefore no 'expr(port)'.
portiter = iter(portlist)
port = portiter.next()
while True:
try:
# If this value of port works, return as promised.
value = expr(port)
except socket.error, err:
# Anything other than 'Address already in use', propagate
if err.args[0] != errno.EADDRINUSE:
raise
# Here we want the next port from portiter. But on StopIteration,
# we want to raise the original exception rather than
# StopIteration. So save the original exc_info().
type, value, tb = sys.exc_info()
try:
try:
port = portiter.next()
except StopIteration:
raise type, value, tb
finally:
# Clean up local traceback, see docs for sys.exc_info()
del tb
else:
debug("freeport() returning %s on port %s", value, port)
return value, port
# Recap of the control flow above:
# If expr(port) doesn't raise, return as promised.
# If expr(port) raises anything but EADDRINUSE, propagate that
# exception.
# If portiter.next() raises StopIteration -- that is, if the port
# value we just passed to expr(port) was the last available -- reraise
# the EADDRINUSE exception.
# If we've actually arrived at this point, portiter.next() delivered a
# new port value. Loop back to pass that to expr(port).
except Exception, err:
debug("*** freeport() raising %s: %s", err.__class__.__name__, err)
raise
def run(*args, **kwds):
"""All positional arguments collectively form a command line, executed as
a synchronous child process.
In addition, pass server=new_thread_instance as an explicit keyword (to
differentiate it from an additional command-line argument).
new_thread_instance should be an instantiated but not yet started Thread
subclass instance, e.g.:
run("python", "-c", 'print "Hello, world!"', server=TestHTTPServer(name="httpd"))
"""
# If there's no server= keyword arg, don't start a server thread: simply
# run a child process.
try:
thread = kwds.pop("server")
except KeyError:
pass
else:
# Start server thread. Note that this and all other comm server
# threads should be daemon threads: we'll let them run "forever,"
# confident that the whole process will terminate when the main thread
# terminates, which will be when the child process terminates.
thread.setDaemon(True)
thread.start()
# choice of os.spawnv():
# - [v vs. l] pass a list of args vs. individual arguments,
# - [no p] don't use the PATH because we specifically want to invoke the
# executable passed as our first arg,
# - [no e] child should inherit this process's environment.
debug("Running %s...", " ".join(args))
if kwds.get("use_path", False):
rc = os.spawnvp(os.P_WAIT, args[0], args)
else:
rc = os.spawnv(os.P_WAIT, args[0], args)
debug("%s returned %s", args[0], rc)
return rc
# ****************************************************************************
# test code -- manual at this point, see SWAT-564
# ****************************************************************************
def test_freeport():
# ------------------------------- Helpers --------------------------------
from contextlib import contextmanager
# helper Context Manager for expecting an exception
# with exc(SomeError):
# raise SomeError()
# raises AssertionError otherwise.
@contextmanager
def exc(exception_class, *args):
try:
yield
except exception_class, err:
for i, expected_arg in enumerate(args):
assert expected_arg == err.args[i], \
"Raised %s, but args[%s] is %r instead of %r" % \
(err.__class__.__name__, i, err.args[i], expected_arg)
print "Caught expected exception %s(%s)" % \
(err.__class__.__name__, ', '.join(repr(arg) for arg in err.args))
else:
assert False, "Failed to raise " + exception_class.__class__.__name__
# helper to raise specified exception
def raiser(exception):
raise exception
# the usual
def assert_equals(a, b):
assert a == b, "%r != %r" % (a, b)
# ------------------------ Sanity check the above ------------------------
class SomeError(Exception): pass
# Without extra args, accept any err.args value
with exc(SomeError):
raiser(SomeError("abc"))
# With extra args, accept only the specified value
with exc(SomeError, "abc"):
raiser(SomeError("abc"))
with exc(AssertionError):
with exc(SomeError, "abc"):
raiser(SomeError("def"))
with exc(AssertionError):
with exc(socket.error, errno.EADDRINUSE):
raiser(socket.error(errno.ECONNREFUSED, 'Connection refused'))
# ----------- freeport() without engaging socket functionality -----------
# If portlist is empty, freeport() raises StopIteration.
with exc(StopIteration):
freeport([], None)
assert_equals(freeport([17], str), ("17", 17))
# This is the magic exception that should prompt us to retry
inuse = socket.error(errno.EADDRINUSE, 'Address already in use')
# Get the iterator to our ports list so we can check later if we've used all
ports = iter(xrange(5))
with exc(socket.error, errno.EADDRINUSE):
freeport(ports, lambda port: raiser(inuse))
# did we entirely exhaust 'ports'?
with exc(StopIteration):
ports.next()
ports = iter(xrange(2))
# Any exception but EADDRINUSE should quit immediately
with exc(SomeError):
freeport(ports, lambda port: raiser(SomeError()))
assert_equals(ports.next(), 1)
# ----------- freeport() with platform-dependent socket stuff ------------
# This is what we should've had unit tests to begin with (see CHOP-661).
def newbind(port):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('127.0.0.1', port))
return sock
bound0, port0 = freeport(xrange(7777, 7780), newbind)
assert_equals(port0, 7777)
bound1, port1 = freeport(xrange(7777, 7780), newbind)
assert_equals(port1, 7778)
bound2, port2 = freeport(xrange(7777, 7780), newbind)
assert_equals(port2, 7779)
with exc(socket.error, errno.EADDRINUSE):
bound3, port3 = freeport(xrange(7777, 7780), newbind)
if __name__ == "__main__":
test_freeport()
indra/llimage/llimage.cpp
+ 1
− 1
View file @ abbf5ff4
......@@ -800,7 +800,7 @@ U8* LLImageBase::getData()
return mData;
}
bool LLImageBase::isBufferInvalid()
bool LLImageBase::isBufferInvalid() const
{
return mBadBufferAllocation || mData == NULL ;
}
......
indra/llimage/llimage.h
+ 1
− 1
View file @ abbf5ff4
......@@ -141,7 +141,7 @@ class LLImageBase
const U8 *getData() const ;
U8 *getData() ;
bool isBufferInvalid() ;
bool isBufferInvalid() const;
void setSize(S32 width, S32 height, S32 ncomponents);
U8* allocateDataSize(S32 width, S32 height, S32 ncomponents, S32 size = -1); // setSize() + allocateData()
......
indra/llmessage/tests/test_llsdmessage_peer.py
+ 16
− 11
View file @ abbf5ff4
......@@ -31,7 +31,6 @@
import os
import sys
from threading import Thread
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
from llbase.fastest_elementtree import parse as xml_parse
......@@ -155,17 +154,23 @@ class Server(HTTPServer):
allow_reuse_address = False
if __name__ == "__main__":
# Instantiate a Server(TestHTTPRequestHandler) on the first free port
# in the specified port range. Doing this inline is better than in a
# daemon thread: if it blows up here, we'll get a traceback. If it blew up
# in some other thread, the traceback would get eaten and we'd run the
# subject test program anyway.
httpd, port = freeport(xrange(8000, 8020),
lambda port: Server(('127.0.0.1', port), TestHTTPRequestHandler))
# function to make a server with specified port
make_server = lambda port: Server(('127.0.0.1', port), TestHTTPRequestHandler)
if not sys.platform.startswith("win"):
# Instantiate a Server(TestHTTPRequestHandler) on a port chosen by the
# runtime.
httpd = make_server(0)
else:
# "Then there's Windows"
# Instantiate a Server(TestHTTPRequestHandler) on the first free port
# in the specified port range.
httpd, port = freeport(xrange(8000, 8020), make_server)
# Pass the selected port number to the subject test program via the
# environment. We don't want to impose requirements on the test program's
# command-line parsing -- and anyway, for C++ integration tests, that's
# performed in TUT code rather than our own.
os.environ["PORT"] = str(port)
debug("$PORT = %s", port)
sys.exit(run(server=Thread(name="httpd", target=httpd.serve_forever), *sys.argv[1:]))
os.environ["PORT"] = str(httpd.server_port)
debug("$PORT = %s", httpd.server_port)
sys.exit(run(server_inst=httpd, *sys.argv[1:]))
indra/llmessage/tests/testrunner.py
+ 64
− 23
View file @ abbf5ff4
......@@ -27,13 +27,12 @@
$/LicenseInfo$
"""
from __future__ import with_statement
import os
import sys
import re
import errno
import socket
import subprocess
VERBOSE = os.environ.get("INTEGRATION_TEST_VERBOSE", "0") # default to quiet
# Support usage such as INTEGRATION_TEST_VERBOSE=off -- distressing to user if
......@@ -47,6 +46,9 @@ def debug(fmt, *args):
else:
debug = lambda *args: None
class Error(Exception):
pass
def freeport(portlist, expr):
"""
Find a free server port to use. Specifically, evaluate 'expr' (a
......@@ -141,34 +143,73 @@ class Server(HTTPServer):
raise
def run(*args, **kwds):
"""All positional arguments collectively form a command line, executed as
a synchronous child process.
In addition, pass server=new_thread_instance as an explicit keyword (to
differentiate it from an additional command-line argument).
new_thread_instance should be an instantiated but not yet started Thread
subclass instance, e.g.:
run("python", "-c", 'print "Hello, world!"', server=TestHTTPServer(name="httpd"))
"""
# If there's no server= keyword arg, don't start a server thread: simply
# run a child process.
Run a specified command as a synchronous child process, optionally
launching a server Thread during the run.
All positional arguments collectively form a command line. The first
positional argument names the program file to execute.
Returns the termination code of the child process.
In addition, you may pass keyword-only arguments:
use_path=True: allow a simple filename as command and search PATH for that
filename. (This argument is retained for backwards compatibility but is
now the default behavior.)
server_inst: an instance of a subclass of SocketServer.BaseServer.
When you pass server_inst, run() calls its handle_request() method in a
loop until the child process terminates.
"""
# server= keyword arg is discontinued
try:
thread = kwds.pop("server")
except KeyError:
pass
else:
# Start server thread. Note that this and all other comm server
# threads should be daemon threads: we'll let them run "forever,"
# confident that the whole process will terminate when the main thread
# terminates, which will be when the child process terminates.
thread.setDaemon(True)
thread.start()
# choice of os.spawnv():
# - [v vs. l] pass a list of args vs. individual arguments,
# - [no p] don't use the PATH because we specifically want to invoke the
# executable passed as our first arg,
# - [no e] child should inherit this process's environment.
raise Error("Obsolete call to testrunner.run(): pass server_inst=, not server=")
debug("Running %s...", " ".join(args))
rc = os.spawnv(os.P_WAIT, args[0], args)
try:
server_inst = kwds.pop("server_inst")
except KeyError:
# Without server_inst, this is very simple: just run child process.
rc = subprocess.call(args)
else:
# We're being asked to run a local server while the child process
# runs. We used to launch a daemon thread calling
# server_inst.serve_forever(), then eventually call sys.exit() with
# the daemon thread still running -- but in recent versions of Python
# 2, even when you call sys.exit(0), apparently killing the thread
# causes the Python runtime to force the process termination code
# nonzero. So now we avoid the extra thread altogether.
# SocketServer.BaseServer.handle_request() honors a 'timeout'
# attribute, if it's set to something other than None.
# We pick 0.5 seconds because that's the default poll timeout for
# BaseServer.serve_forever(), which is what we used to use.
server_inst.timeout = 0.5
child = subprocess.Popen(args)
while child.poll() is None:
# Setting server_inst.timeout is what keeps this handle_request()
# call from blocking "forever." Interestingly, looping over
# handle_request() with a timeout is very like the implementation
# of serve_forever(). We just check a different flag to break out.
# It might be interesting if handle_request() returned an
# indication of whether it in fact handled a request or timed out.
# Oddly, it doesn't. We could discover that by overriding
# handle_timeout(), whose default implementation does nothing --
# but in fact we really don't care. All that matters is that we
# regularly poll both the child process and the server socket.
server_inst.handle_request()
# We don't bother to capture the rc returned by child.poll() because
# poll() is already defined to capture that in its returncode attr.
rc = child.returncode
debug("%s returned %s", args[0], rc)
return rc
......
indra/llrender/llimagegl.cpp
+ 6
− 0
View file @ abbf5ff4
......@@ -1267,6 +1267,12 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
llassert(gGLManager.mInited);
stop_glerror();
if (!imageraw || imageraw->isBufferInvalid())
{
LL_WARNS() << "Trying to create a texture from invalid image data" << LL_ENDL;
return FALSE;
}
if (discard_level < 0)
{
llassert(mCurrentDiscardLevel >= 0);
......
indra/newview/tests/test_llxmlrpc_peer.py
+ 25
− 11
View file @ abbf5ff4
......@@ -31,15 +31,23 @@
import os
import sys
from threading import Thread
from SimpleXMLRPCServer import SimpleXMLRPCServer
mydir = os.path.dirname(__file__) # expected to be .../indra/newview/tests/
sys.path.insert(0, os.path.join(mydir, os.pardir, os.pardir, "lib", "python"))
sys.path.insert(1, os.path.join(mydir, os.pardir, os.pardir, "llmessage", "tests"))
sys.path.insert(0, os.path.join(mydir, os.pardir, os.pardir, "llmessage", "tests"))
from testrunner import freeport, run, debug
class TestServer(SimpleXMLRPCServer):
# This server_bind() override is borrowed and simplified from
# BaseHTTPServer.HTTPServer.server_bind(): we want to capture the actual
# server port. BaseHTTPServer.HTTPServer.server_bind() stores the actual
# port in a server_port attribute, but SimpleXMLRPCServer isn't derived
# from HTTPServer. So do it ourselves.
def server_bind(self):
"""Override server_bind to store the server port."""
SimpleXMLRPCServer.server_bind(self)
self.server_port = self.socket.getsockname()[1]
def _dispatch(self, method, params):
try:
func = getattr(self, method)
......@@ -67,15 +75,21 @@ def log_error(self, format, *args):
pass
if __name__ == "__main__":
# Instantiate a TestServer on the first free port in the specified port
# range. Doing this inline is better than in a daemon thread: if it blows
# up here, we'll get a traceback. If it blew up in some other thread, the
# traceback would get eaten and we'd run the subject test program anyway.
xmlrpcd, port = freeport(xrange(8000, 8020),
lambda port: TestServer(('127.0.0.1', port)))
# function to make a server with specified port
make_server = lambda port: TestServer(('127.0.0.1', port))
if not sys.platform.startswith("win"):
# Instantiate a TestServer on a port chosen by the runtime.
xmlrpcd = make_server(0)
else:
# "Then there's Windows"
# Instantiate a TestServer on the first free port in the specified
# port range.
xmlrpcd, port = freeport(xrange(8000, 8020), make_server)
# Pass the selected port number to the subject test program via the
# environment. We don't want to impose requirements on the test program's
# command-line parsing -- and anyway, for C++ integration tests, that's
# performed in TUT code rather than our own.
os.environ["PORT"] = str(port)
sys.exit(run(server=Thread(name="xmlrpc", target=xmlrpcd.serve_forever), *sys.argv[1:]))
os.environ["PORT"] = str(xmlrpcd.server_port)
sys.exit(run(server_inst=xmlrpcd, *sys.argv[1:]))
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment