rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/test/tokenize_tests.py

@@ -0,0 +1,175 @@
+# Tests for the 'tokenize' module.
+# Large bits stolen from test_grammar.py. 
+
+# Comments
+"#"
+#'
+#"
+#\
+       #
+    # abc
+'''#
+#'''
+
+x = 1  #
+
+# Balancing continuation
+
+a = (3, 4,
+  5, 6)
+y = [3, 4,
+  5]
+z = {'a':5,
+  'b':6}
+x = (len(`y`) + 5*x - a[
+   3 ]
+   - x + len({
+   }
+    )
+  )
+
+# Backslash means line continuation:
+x = 1 \
++ 1
+
+# Backslash does not means continuation in comments :\
+x = 0
+
+# Ordinary integers
+0xff <> 255
+0377 <> 255
+2147483647   != 017777777777
+-2147483647-1 != 020000000000
+037777777777 != -1
+0xffffffff != -1
+
+# Long integers
+x = 0L
+x = 0l
+x = 0xffffffffffffffffL
+x = 0xffffffffffffffffl
+x = 077777777777777777L
+x = 077777777777777777l
+x = 123456789012345678901234567890L
+x = 123456789012345678901234567890l
+
+# Floating-point numbers
+x = 3.14
+x = 314.
+x = 0.314
+# XXX x = 000.314
+x = .314
+x = 3e14
+x = 3E14
+x = 3e-14
+x = 3e+14
+x = 3.e14
+x = .3e14
+x = 3.1e4
+
+# String literals
+x = ''; y = "";
+x = '\''; y = "'";
+x = '"'; y = "\"";
+x = "doesn't \"shrink\" does it"
+y = 'doesn\'t "shrink" does it'
+x = "does \"shrink\" doesn't it"
+y = 'does "shrink" doesn\'t it'
+x = """
+The "quick"
+brown fox
+jumps over
+the 'lazy' dog.
+"""
+y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n'
+y = '''
+The "quick"
+brown fox
+jumps over
+the 'lazy' dog.
+''';
+y = "\n\
+The \"quick\"\n\
+brown fox\n\
+jumps over\n\
+the 'lazy' dog.\n\
+";
+y = '\n\
+The \"quick\"\n\
+brown fox\n\
+jumps over\n\
+the \'lazy\' dog.\n\
+';
+x = r'\\' + R'\\'
+x = r'\'' + ''
+y = r'''
+foo bar \\
+baz''' + R'''
+foo'''
+y = r"""foo
+bar \\ baz
+""" + R'''spam
+'''
+x = u'abc' + U'ABC'
+y = u"abc" + U"ABC"
+x = ur'abc' + Ur'ABC' + uR'ABC' + UR'ABC'
+y = ur"abc" + Ur"ABC" + uR"ABC" + UR"ABC"
+x = ur'\\' + UR'\\'
+x = ur'\'' + ''
+y = ur'''
+foo bar \\
+baz''' + UR'''
+foo'''
+y = Ur"""foo
+bar \\ baz
+""" + uR'''spam
+'''
+
+# Indentation
+if 1:
+    x = 2
+if 1:
+        x = 2
+if 1:
+    while 0:
+     if 0:
+           x = 2
+     x = 2
+if 0:
+  if 2:
+   while 0:
+        if 1:
+          x = 2
+
+# Operators
+
+def d22(a, b, c=1, d=2): pass
+def d01v(a=1, *restt, **restd): pass
+
+(x, y) <> ({'a':1}, {'b':2})
+
+# comparison
+if 1 < 1 > 1 == 1 >= 1 <= 1 <> 1 != 1 in 1 not in 1 is 1 is not 1: pass
+
+# binary
+x = 1 & 1
+x = 1 ^ 1
+x = 1 | 1
+
+# shift
+x = 1 << 1 >> 1
+
+# additive
+x = 1 - 1 + 1 - 1 + 1
+
+# multiplicative
+x = 1 / 1 * 1 % 1
+
+# unary
+x = ~1 ^ 1 & 1 | 1 & 1 ^ -1
+x = -1*1/1 + 1*1 - ---1*1
+
+# selector
+import sys, time
+x = sys.modules['time'].time()
+

data/lib/rubyfox/server/data/lib/Lib/test/whrandom.py

@@ -0,0 +1,96 @@
+#	WICHMANN-HILL RANDOM NUMBER GENERATOR
+#
+#	Wichmann, B. A. & Hill, I. D. (1982)
+#	Algorithm AS 183: 
+#	An efficient and portable pseudo-random number generator
+#	Applied Statistics 31 (1982) 188-190
+#
+#	see also: 
+#		Correction to Algorithm AS 183
+#		Applied Statistics 33 (1984) 123  
+#
+#		McLeod, A. I. (1985)
+#		A remark on Algorithm AS 183 
+#		Applied Statistics 34 (1985),198-200
+#
+#
+#	USE:
+#	whrandom.random()	yields double precision random numbers 
+#				uniformly distributed between 0 and 1.
+#
+#	whrandom.seed(x, y, z)	must be called before whrandom.random()
+#				to seed the generator
+#
+#	There is also an interface to create multiple independent
+#	random generators, and to choose from other ranges.
+
+
+#	Translated by Guido van Rossum from C source provided by
+#	Adrian Baddeley.
+
+
+class whrandom:
+	#
+	# Initialize an instance.
+	# Without arguments, initialize from current time.
+	# With arguments (x, y, z), initialize from them.
+	#
+	def __init__(self, x = 0, y = 0, z = 0):
+		self.seed(x, y, z)
+	#
+	# Set the seed from (x, y, z).
+	# These must be integers in the range [0, 256).
+	#
+	def seed(self, x = 0, y = 0, z = 0):
+		if not type(x) == type(y) == type(z) == type(0):
+			raise TypeError, 'seeds must be integers'
+		if not (0 <= x < 256 and 0 <= y < 256 and 0 <= z < 256):
+			raise ValueError, 'seeds must be in range(0, 256)'
+		if 0 == x == y == z:
+			# Initialize from current time
+			import time
+			t = long(time.time() * 256)
+			t = int((t&0xffffff) ^ (t>>24))
+			t, x = divmod(t, 256)
+			t, y = divmod(t, 256)
+			t, z = divmod(t, 256)
+		# Zero is a poor seed, so substitute 1
+		self._seed = (x or 1, y or 1, z or 1)
+	#
+	# Get the next random number in the range [0.0, 1.0).
+	#
+	def random(self):
+		x, y, z = self._seed
+		#
+		x = (171 * x) % 30269
+		y = (172 * y) % 30307
+		z = (170 * z) % 30323
+		#
+		self._seed = x, y, z
+		#
+		return (x/30269.0 + y/30307.0 + z/30323.0) % 1.0
+	#
+	# Get a random number in the range [a, b).
+	#
+	def uniform(self, a, b):
+		return a + (b-a) * self.random()
+	#
+	# Get a random integer in the range [a, b] including both end points.
+	#
+	def randint(self, a, b):
+		return a + int(self.random() * (b+1-a))
+	#
+	# Choose a random element from a non-empty sequence.
+	#
+	def choice(self, seq):
+		return seq[int(self.random() * len(seq))]
+
+
+# Initialize from the current time
+#
+_inst = whrandom()
+seed = _inst.seed
+random = _inst.random
+uniform = _inst.uniform
+randint = _inst.randint
+choice = _inst.choice

data/lib/rubyfox/server/data/lib/Lib/test/zxjdbc/dbextstest.py

@@ -0,0 +1,266 @@
+
+# Jython Database Specification API 2.0
+#
+# $Id: dbextstest.py 2101 2002-05-10 16:11:41Z bzimmer $
+#
+# Copyright (c) 2001 brian zimmer <bzimmer@ziclix.com>
+
+import dbexts, runner, tempfile, os
+from random import random
+
+class dbextsTestCase(runner.SQLTestCase):
+
+	def setUp(self):
+		template = """
+			[default]
+			name=dbexts_test
+
+			[jdbc]
+			name=dbexts_test
+			url=%s
+			user=%s
+			pwd=%s
+			driver=%s
+		"""
+
+		args = {}
+		for arg in self.factory.arguments:
+			args[arg[0]] = arg[1]
+
+		template = template % (args["url"], args["usr"], args["pwd"], args["driver"])
+		if hasattr(self, "datahandler"):
+			template += "\tdatahandler=%s" % (self.datahandler.__name__)
+		template = os.linesep.join(template.split())
+
+		try:
+			fp = open(tempfile.mktemp(), "w")
+			fp.write(template)
+			fp.close()
+			self.db = dbexts.dbexts(cfg=fp.name)
+			self.db.verbose = 0
+			for table in ("one", "two"):
+				try: self.db.raw("drop table %s" % (table))
+				except: pass
+			self.db.raw("create table one (a int, b int, c varchar(32))")
+			self.db.raw("create table two (a int, b int, c varchar(32))")
+		finally:
+			try:
+				os.remove(fp.name)
+			except:
+				pass
+
+	def tearDown(self):
+		self.db.raw("drop table one")
+		self.db.raw("drop table two")
+		self.db.close()
+
+	def testChoose(self):
+		"""testing choose()"""
+		r = dbexts.choose(1, 4, 5)
+		assert r == 4, "choose failed, expected 4, got %d" % r
+
+	def _insertInto(self, table, num):
+		for i in range(0, num):
+			self.db.raw("insert into %s (a, b, c) values (?, ?, ?)" % (table), [(i, random()*100+i, "%s" % (random()*100+i))])
+
+	def testSqlFailure(self):
+		"""testing isql with sql exception"""
+		try:
+			self.db.isql("select * from __garbage__")
+			self.fail("expected SQL exception")
+		except:
+			pass
+
+	def testSqlFailureWithBeginCommit(self):
+		"""testing failure with begin/commit"""
+		failed = 0
+		c = self.db.begin()
+		try:
+			try:
+				c.execute("select * from __garbage__")
+			except:
+				failed = 1
+		finally:
+			self.db.commit(c)
+
+		if not failed:
+			self.fail("expected SQL exception")
+
+	def testSqlWithBeginCommit(self):
+		"""testing begin/commit"""
+		self._insertInto("two", 30)
+		c = self.db.begin()
+		c.execute("select * from two")
+		f = c.fetchall()
+		c.close()
+		self.db.commit()
+		assert len(f) == 30, "expected [30], got [%d]" % (len(f))
+
+	def testQueryMultipleReturnSets(self):
+		"""testing multiple return sets"""
+		self._insertInto("two", 30)
+		h, r = self.db.raw("select * from two where a = ?", [(0,), (3,)])
+		assert len(r) == 2, "expected [2], got [%d]" % (len(r))
+
+	def testUpdateCount(self):
+		"""testing update count"""
+
+		self._insertInto("one", 45)
+		self.db.raw("delete from one where a > ?", [(12,)])
+		self.assertEquals(32, self.db.updatecount)
+
+	def testQueryWithMaxRows(self):
+		"""testing query with max rows"""
+
+		self._insertInto("one", 45)
+		self.db.raw("select * from one", maxrows=3)
+		self.assertEquals(3, len(self.db.results))
+		self.db.raw("select * from one where a > ?", [(12,)], maxrows=3)
+		self.assertEquals(3, len(self.db.results))
+
+	def testBulkcopy(self):
+		"""testing bcp"""
+
+		self._insertInto("two", 3)
+
+		bcp = self.db.bulkcopy("dbexts_test", "two", include=['a'])
+		assert len(bcp.columns) == 1, "one column should be specified, [%d] found" % (len(bcp.columns))
+
+		bcp = self.db.bulkcopy("dbexts_test", "two", include=['a', 'b', 'c'], exclude=['a'])
+		assert len(bcp.columns) == 2, "expected two columns, found [%d]" % (len(bcp.columns))
+		a = filter(lambda x, c=bcp.columns: x in c, ['b', 'c'])
+		assert a, "expecting ['b', 'c'], found %s" % (str(a))
+
+		class _executor:
+			def __init__(self, table, cols):
+				self.cols = cols
+				if cols:
+					self.sql = "insert into %s (%s) values (%s)" % (table, ",".join(self.cols), ",".join(("?",) * len(self.cols)))
+				else:
+					self.sql = "insert into %s values (%%s)" % (table)
+			def execute(self, db, rows, bindings):
+				assert len(rows) > 0, "must have at least one row"
+				if self.cols:
+					sql = self.sql
+				else:
+					sql = self.sql % (",".join(("?",) * len(rows[0])))
+
+		bcp = self.db.bulkcopy("dbexts_test", "two", include=['a'], executor=_executor)
+		done = bcp.transfer(self.db)
+		assert done == 3, "expecting three rows to be handled but not inserted, found [%d]" % (done)
+
+		bcp = self.db.bulkcopy("dbexts_test", "two", include=['a'])
+		done = bcp.transfer(self.db)
+		assert done == 3, "expecting three rows to be inserted, found [%d]" % (done)
+
+		bcp = self.db.bulkcopy("dbexts_test", "two", include=['a'])
+		bcp.rowxfer([200])
+		bcp.rowxfer([201])
+		bcp.rowxfer([202])
+		bcp.rowxfer([203])
+		done = bcp.batch()
+		assert done == 4, "expecting four rows to be inserted, found [%d]" % (done)
+		bcp.rowxfer([300])
+		bcp.rowxfer([401])
+		bcp.rowxfer([502])
+		bcp.rowxfer([603])
+		done = bcp.batch()
+		assert done == 4, "expecting four rows to be inserted, found [%d]" % (done)
+		bcp.rowxfer([205])
+		bcp.rowxfer([210])
+		done = bcp.done()
+		assert done == 2, "expecting two rows to be inserted, found [%d]" % (done)
+		assert bcp.total == 10, "expecting 10 rows to be inserted, found [%d]" % (bcp.total)
+
+		bcp = self.db.bulkcopy("dbexts_test", "two", include=['a'])
+		done = bcp.transfer(self.db)
+		assert done == 16, "expecting sixteen rows to be inserted, found [%d]" % (done)
+
+	def testTable(self):
+		"""testing dbexts.table(tabname)"""
+		self.db.table("one")
+		assert self.db.results is not None, "results were None"
+		self.assertEquals(3, len(self.db.results))
+		self.db.table()
+		found = 0
+		for a in self.db.results:
+			if a[2].lower() in ("one", "two"): found += 1
+		self.assertEquals(2, found)
+
+	def testOut(self):
+		"""testing dbexts.out"""
+		self.db.verbose = 1
+		fp = open(tempfile.mktemp(), "w")
+		try:
+			self.db.out = fp
+			self.db.raw("insert into one (a, b) values (?, ?)", [(1, 2), (3, 4)])
+			self.db.isql("select * from one")
+			self.db.verbose = 0
+			fp.close()
+			fp = open(fp.name, "r")
+			data = fp.read()
+			assert len(data), "expected file to contain output"
+		finally:
+			fp.close()
+			os.remove(fp.name)
+
+	def testResultSetWrapper(self):
+		"""testing result set wrapper"""
+		from dbexts import ResultSet
+		self._insertInto("two", 30)
+		h, r = self.db.raw("select * from two where a in (?, ?, ?, ?) order by a", [(12,15,17,8)])
+		assert len(r) == 4, "expected [4], got [%d]" % (len(r))
+		rs = ResultSet(map(lambda x: x[0], h), r)
+		assert len(rs[0]) == 3, "expected [3], got [%d]" % (len(rs[0]))
+		assert rs[0]['a'] == 8, "expected [8], got [%s]" % (rs[0]['a'])
+		assert rs[0]['A'] == 8, "expected [8], got [%s]" % (rs[0]['A'])
+		assert len(rs[0]['b':]) == 2, "expected [2], got [%s]" % (len(rs[0]['b':]))
+		assert len(rs[0]['a':'b']) == 1, "expected [1], got [%s]" % (len(rs[0]['a':'b']))
+
+	def testMultipleResultSetConcatentation(self):
+		"""testing multiple result sets with some resulting in None"""
+		self._insertInto("two", 30)
+		# first is non None
+		h, r = self.db.raw("select * from two where a = ?", [(12,),(8001,),(15,),(17,),(8,),(9001,)])
+		assert len(r) == 4, "expected [4], got [%d]" % (len(r))
+		# first is None
+		h, r = self.db.raw("select * from two where a = ?", [(1200,),(8001,),(15,),(17,),(8,),(9001,)])
+		assert len(r) == 3, "expected [3], got [%d]" % (len(r))
+
+	def testBulkcopyWithDynamicColumns(self):
+		"""testing bcp with dynamic column names"""
+
+		self.testBulkcopy()
+
+		bcp = self.db.bulkcopy("dbexts_test", "two", exclude=['a'])
+		assert len(bcp.columns) == 2, "expected two columns, found [%d]" % (len(bcp.columns))
+		a = filter(lambda x, c=bcp.columns: x in c, ['b', 'c'])
+		assert a == ['b', 'c'], "expecting ['b', 'c'], found %s" % (str(a))
+
+		bcp = self.db.bulkcopy("dbexts_test", "two")
+		done = bcp.transfer(self.db)
+		assert done == 32, "expecting thirty two rows to be inserted, found [%d]" % (done)
+
+	def testAutocommit(self):
+		"""testing the autocommit functionality"""
+		for u in (0, 1):
+			self.db.autocommit = u
+			try:
+				self.db.isql("select * from one")
+			except Exception, e:
+				fail("failed autocommit query with u=[%d], v=[%d]" % (u, v))
+			for v in (0, 1):
+				self.db.db.autocommit = v
+				try:
+					self.db.isql("select * from one")
+				except Exception, e:
+					self.fail("failed autocommit query with u=[%d], v=[%d]" % (u, v))
+
+	def testPrepare(self):
+		"""testing the handling of a prepared statement"""
+		self._insertInto("one", 10)
+		p = self.db.prepare("select * from one")
+		self.db.isql(p)
+		self.db.isql(p)
+		p.close()
+		assert p.closed

data/lib/rubyfox/server/data/lib/Lib/test/zxjdbc/jndi.py

@@ -0,0 +1,33 @@
+
+# Jython Database Specification API 2.0
+#
+# $Id: jndi.py 1962 2001-12-14 04:20:03Z bzimmer $
+#
+# Copyright (c) 2001 brian zimmer <bzimmer@ziclix.com>
+
+"""
+	This script is used to bind a JNDI reference for testing purposes only.
+"""
+from java.util import Hashtable
+from org.gjt.mm.mysql import MysqlDataSource
+from javax.naming import Context, InitialContext, NameAlreadyBoundException
+
+env = Hashtable()
+env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory")
+
+ds = MysqlDataSource()
+ds.setServerName("localhost")
+ds.setDatabaseName("ziclix")
+ds.setPort(3306)
+
+ctx = InitialContext(env)
+try:
+	try:
+		ctx.bind("/jdbc/mysqldb", ds)
+	except NameAlreadyBoundException, e:
+		ctx.unbind("/jdbc/mysqldb")
+		ctx.bind("/jdbc/mysqldb", ds)
+finally:
+	ctx.close()
+
+print "bound [%s] at /jdbc/mysqldb" % (ds)