merge with raichoo/pygments-main (pull request #210)

36 files changed, 1409 insertions, 244 deletions

diff --git a/tests/examplefiles/99_bottles_of_beer.chpl b/tests/examplefiles/99_bottles_of_beer.chpl
new file mode 100644
index 00000000..f73be7b1
--- /dev/null
+++ b/tests/examplefiles/99_bottles_of_beer.chpl
@@ -0,0 +1,118 @@
+/***********************************************************************
+ * Chapel implementation of "99 bottles of beer"
+ *
+ * by Brad Chamberlain and Steve Deitz
+ * 07/13/2006 in Knoxville airport while waiting for flight home from
+ *            HPLS workshop
+ * compiles and runs with chpl compiler version 1.7.0
+ * for more information, contact: chapel_info@cray.com
+ * 
+ *
+ * Notes: 
+ * o as in all good parallel computations, boundary conditions
+ *   constitute the vast bulk of complexity in this code (invite Brad to
+ *   tell you about his zany boundary condition simplification scheme)
+ * o uses type inference for variables, arguments
+ * o relies on integer->string coercions
+ * o uses named argument passing (for documentation purposes only)
+ ***********************************************************************/
+ 
+// allow executable command-line specification of number of bottles 
+// (e.g., ./a.out -snumBottles=999999)
+config const numBottles = 99;
+const numVerses = numBottles+1;
+ 
+// a domain to describe the space of lyrics
+var LyricsSpace: domain(1) = {1..numVerses};
+ 
+// array of lyrics
+var Lyrics: [LyricsSpace] string;
+ 
+// parallel computation of lyrics array
+[verse in LyricsSpace] Lyrics(verse) = computeLyric(verse);
+ 
+// as in any good parallel language, I/O to stdout is serialized.
+// (Note that I/O to a file could be parallelized using a parallel
+// prefix computation on the verse strings' lengths with file seeking)
+writeln(Lyrics);
+ 
+ 
+// HELPER FUNCTIONS:
+ 
+proc computeLyric(verseNum) {
+  var bottleNum = numBottles - (verseNum - 1);
+  var nextBottle = (bottleNum + numVerses - 1)%numVerses;
+  return "\n" // disguise space used to separate elements in array I/O
+    + describeBottles(bottleNum, startOfVerse=true) + " on the wall, "
+    + describeBottles(bottleNum) + ".\n"
+    + computeAction(bottleNum)
+    + describeBottles(nextBottle) + " on the wall.\n";
+}
+ 
+ 
+proc describeBottles(bottleNum, startOfVerse:bool = false) {
+  // NOTE: bool should not be necessary here (^^^^); working around bug
+  var bottleDescription = if (bottleNum) then bottleNum:string 
+    else (if startOfVerse then "N" 
+            else "n") 
+           + "o more";
+  return bottleDescription 
+    + " bottle" + (if (bottleNum == 1) then "" else "s") 
+    + " of beer";
+}
+ 
+ 
+proc computeAction(bottleNum) {
+  return if (bottleNum == 0) then "Go to the store and buy some more, "
+    else "Take one down and pass it around, ";
+}
+
+
+// Modules...
+module M1 {
+  var x = 10;
+}
+
+module M2 {
+  use M1;
+  proc main() {
+    writeln("M2 -> M1 -> x " + x);
+  }
+}
+
+
+// Classes, records, unions...
+const PI: real = 3.14159;
+
+record Point {
+  var x, y: real;
+}
+var p: Point;
+writeln("Distance from origin: " + sqrt(p.x ** 2 + p.y ** 2)); 
+p = new Point(1.0, 2.0);
+writeln("Distance from origin: " + sqrt(p.x ** 2 + p.y ** 2)); 
+
+class Circle {
+  var p: Point;
+  var r: real;
+}
+var c = new Circle(r=2.0);
+proc Circle.area()
+  return PI * r ** 2;
+writeln("Area of circle: " + c.area());
+
+class Oval: Circle {
+  var r2: real;
+}
+proc Oval.area()
+  return PI * r * r2;
+
+delete c;
+c = nil;
+c = new Oval(r=1.0, r2=2.0);
+writeln("Area of oval: " + c.area());
+
+union U {
+  var i: int;
+  var r: real;
+}
diff --git a/tests/examplefiles/Error.pmod b/tests/examplefiles/Error.pmod
new file mode 100644
index 00000000..808ecb0e
--- /dev/null
+++ b/tests/examplefiles/Error.pmod
@@ -0,0 +1,38 @@
+#pike __REAL_VERSION__
+
+constant Generic = __builtin.GenericError;
+
+constant Index = __builtin.IndexError;
+
+constant BadArgument = __builtin.BadArgumentError;
+
+constant Math = __builtin.MathError;
+
+constant Resource = __builtin.ResourceError;
+
+constant Permission = __builtin.PermissionError;
+
+constant Decode = __builtin.DecodeError;
+
+constant Cpp = __builtin.CppError;
+
+constant Compilation = __builtin.CompilationError;
+
+constant MasterLoad = __builtin.MasterLoadError;
+
+constant ModuleLoad = __builtin.ModuleLoadError;
+
+//! Returns an Error object for any argument it receives. If the
+//! argument already is an Error object or is empty, it does nothing.
+object mkerror(mixed error)
+{
+  if (error == UNDEFINED)
+    return error;
+  if (objectp(error) && error->is_generic_error)
+    return error;
+  if (arrayp(error))
+    return Error.Generic(@error);
+  if (stringp(error))
+    return Error.Generic(error);
+  return Error.Generic(sprintf("%O", error));
+}
\ No newline at end of file
diff --git a/tests/examplefiles/FakeFile.pike b/tests/examplefiles/FakeFile.pike
new file mode 100644
index 00000000..48f3ea64
--- /dev/null
+++ b/tests/examplefiles/FakeFile.pike
@@ -0,0 +1,360 @@
+#pike __REAL_VERSION__
+
+//! A string wrapper that pretends to be a @[Stdio.File] object
+//! in addition to some features of a @[Stdio.FILE] object.
+
+
+//! This constant can be used to distinguish a FakeFile object
+//! from a real @[Stdio.File] object.
+constant is_fake_file = 1;
+
+protected string data;
+protected int ptr;
+protected int(0..1) r;
+protected int(0..1) w;
+protected int mtime;
+
+protected function read_cb;
+protected function read_oob_cb;
+protected function write_cb;
+protected function write_oob_cb;
+protected function close_cb;
+
+//! @seealso
+//!   @[Stdio.File()->close()]
+int close(void|string direction) {
+  direction = lower_case(direction||"rw");
+  int cr = has_value(direction, "r");
+  int cw = has_value(direction, "w");
+
+  if(cr) {
+    r = 0;
+  }
+
+  if(cw) {
+    w = 0;
+  }
+
+  // FIXME: Close callback
+  return 1;
+}
+
+//! @decl void create(string data, void|string type, void|int pointer)
+//! @seealso
+//!   @[Stdio.File()->create()]
+void create(string _data, void|string type, int|void _ptr) {
+  if(!_data) error("No data string given to FakeFile.\n");
+  data = _data;
+  ptr = _ptr;
+  mtime = time();
+  if(type) {
+    type = lower_case(type);
+    if(has_value(type, "r"))
+      r = 1;
+    if(has_value(type, "w"))
+      w = 1;
+  }
+  else
+    r = w = 1;
+}
+
+protected string make_type_str() {
+  string type = "";
+  if(r) type += "r";
+  if(w) type += "w";
+  return type;
+}
+
+//! @seealso
+//!   @[Stdio.File()->dup()]
+this_program dup() {
+  return this_program(data, make_type_str(), ptr);
+}
+
+//! Always returns 0.
+//! @seealso
+//!   @[Stdio.File()->errno()]
+int errno() { return 0; }
+
+//! Returns size and the creation time of the string.
+Stdio.Stat stat() {
+  Stdio.Stat st = Stdio.Stat();
+  st->size = sizeof(data);
+  st->mtime=st->ctime=mtime;
+  st->atime=time();
+  return st;
+}
+
+//! @seealso
+//!   @[Stdio.File()->line_iterator()]
+String.SplitIterator line_iterator(int|void trim) {
+  if(trim)
+    return String.SplitIterator( data-"\r", '\n' );
+  return String.SplitIterator( data, '\n' );
+}
+
+protected mixed id;
+
+//! @seealso
+//!   @[Stdio.File()->query_id()]
+mixed query_id() { return id; }
+
+//! @seealso
+//!   @[Stdio.File()->set_id()]
+void set_id(mixed _id) { id = _id; }
+
+//! @seealso
+//!   @[Stdio.File()->read_function()]
+function(:string) read_function(int nbytes) {
+  return lambda() { return read(nbytes); };
+}
+
+//! @seealso
+//!   @[Stdio.File()->peek()]
+int(-1..1) peek(int|float|void timeout) {
+  if(!r) return -1;
+  if(ptr >= sizeof(data)) return 0;
+  return 1;
+}
+
+//! Always returns 0.
+//! @seealso
+//!   @[Stdio.File()->query_address()]
+string query_address(void|int(0..1) is_local) { return 0; }
+
+//! @seealso
+//!   @[Stdio.File()->read()]
+string read(void|int(0..) len, void|int(0..1) not_all) {
+  if(!r) return 0;
+  if (len < 0) error("Cannot read negative number of characters.\n");
+  int start=ptr;
+  ptr += len;
+  if(zero_type(len) || ptr>sizeof(data))
+    ptr = sizeof(data);
+
+  // FIXME: read callback
+  return data[start..ptr-1];
+}
+
+//! @seealso
+//!   @[Stdio.FILE()->gets()]
+string gets() {
+  if(!r) return 0;
+  string ret;
+  sscanf(data,"%*"+(string)ptr+"s%[^\n]",ret);
+  if(ret)
+  {
+    ptr+=sizeof(ret)+1;
+    if(ptr>sizeof(data))
+    {
+      ptr=sizeof(data);
+      if(!sizeof(ret))
+	ret = 0;
+    }
+  }
+
+  // FIXME: read callback
+  return ret;
+}
+
+//! @seealso
+//!   @[Stdio.FILE()->getchar()]
+int getchar() {
+  if(!r) return 0;
+  int c;
+  if(catch(c=data[ptr]))
+    c=-1;
+  else
+    ptr++;
+
+  // FIXME: read callback
+  return c;
+}
+
+//! @seealso
+//!   @[Stdio.FILE()->unread()]
+void unread(string s) {
+  if(!r) return;
+  if(data[ptr-sizeof(s)..ptr-1]==s)
+    ptr-=sizeof(s);
+  else
+  {
+    data=s+data[ptr..];
+    ptr=0;
+  }
+}
+
+//! @seealso
+//!   @[Stdio.File()->seek()]
+int seek(int pos, void|int mult, void|int add) {
+  if(mult)
+    pos = pos*mult+add;
+  if(pos<0)
+  {
+    pos = sizeof(data)+pos;
+    if( pos < 0 )
+	pos = 0;
+  }
+  ptr = pos;
+  if( ptr > strlen( data ) )
+      ptr = strlen(data);
+  return ptr;
+}
+
+//! Always returns 1.
+//! @seealso
+//!   @[Stdio.File()->sync()]
+int(1..1) sync() { return 1; }
+
+//! @seealso
+//!   @[Stdio.File()->tell()]
+int tell() { return ptr; }
+
+//! @seealso
+//!   @[Stdio.File()->truncate()]
+int(0..1) truncate(int length) {
+  data = data[..length-1];
+  return sizeof(data)==length;
+}
+
+//! @seealso
+//!   @[Stdio.File()->write()]
+int(-1..) write(string|array(string) str, mixed ... extra) {
+  if(!w) return -1;
+  if(arrayp(str)) str=str*"";
+  if(sizeof(extra)) str=sprintf(str, @extra);
+
+  if(ptr==sizeof(data)) {
+    data += str;
+    ptr = sizeof(data);
+  }
+  else if(sizeof(str)==1)
+    data[ptr++] = str[0];
+  else {
+    data = data[..ptr-1] + str + data[ptr+sizeof(str)..];
+    ptr += sizeof(str);
+  }
+
+  // FIXME: write callback
+  return sizeof(str);
+}
+
+//! @seealso
+//!   @[Stdio.File()->set_blocking]
+void set_blocking() {
+  close_cb = 0;
+  read_cb = 0;
+  read_oob_cb = 0;
+  write_cb = 0;
+  write_oob_cb = 0;
+}
+
+//! @seealso
+//!   @[Stdio.File()->set_blocking_keep_callbacks]
+void set_blocking_keep_callbacks() { }
+
+//! @seealso
+//!   @[Stdio.File()->set_blocking]
+void set_nonblocking(function rcb, function wcb, function ccb,
+		     function rocb, function wocb) {
+  read_cb = rcb;
+  write_cb = wcb;
+  close_cb = ccb;
+  read_oob_cb = rocb;
+  write_oob_cb = wocb;
+}
+
+//! @seealso
+//!   @[Stdio.File()->set_blocking_keep_callbacks]
+void set_nonblocking_keep_callbacks() { }
+
+
+//! @seealso
+//!   @[Stdio.File()->set_close_callback]
+void set_close_callback(function cb) { close_cb = cb; }
+
+//! @seealso
+//!   @[Stdio.File()->set_read_callback]
+void set_read_callback(function cb) { read_cb = cb; }
+
+//! @seealso
+//!   @[Stdio.File()->set_read_oob_callback]
+void set_read_oob_callback(function cb) { read_oob_cb = cb; }
+
+//! @seealso
+//!   @[Stdio.File()->set_write_callback]
+void set_write_callback(function cb) { write_cb = cb; }
+
+//! @seealso
+//!   @[Stdio.File()->set_write_oob_callback]
+void set_write_oob_callback(function cb) { write_oob_cb = cb; }
+
+
+//! @seealso
+//!   @[Stdio.File()->query_close_callback]
+function query_close_callback() { return close_cb; }
+
+//! @seealso
+//!   @[Stdio.File()->query_read_callback]
+function query_read_callback() { return read_cb; }
+
+//! @seealso
+//!   @[Stdio.File()->query_read_oob_callback]
+function query_read_oob_callback() { return read_oob_cb; }
+
+//! @seealso
+//!   @[Stdio.File()->query_write_callback]
+function query_write_callback() { return write_cb; }
+
+//! @seealso
+//!   @[Stdio.File()->query_write_oob_callback]
+function query_write_oob_callback() { return write_oob_cb; }
+
+string _sprintf(int t) {
+  return t=='O' && sprintf("%O(%d,%O)", this_program, sizeof(data),
+			   make_type_str());
+}
+
+
+// FakeFile specials.
+
+//! A FakeFile can be casted to a string.
+mixed cast(string to) {
+  switch(to) {
+  case "string": return data;
+  case "object": return this;
+  }
+  error("Can not cast object to %O.\n", to);
+}
+
+//! Sizeof on a FakeFile returns the size of its contents.
+int(0..) _sizeof() {
+  return sizeof(data);
+}
+
+//! @ignore
+
+#define NOPE(X) mixed X (mixed ... args) { error("This is a FakeFile. %s is not available.\n", #X); }
+NOPE(assign);
+NOPE(async_connect);
+NOPE(connect);
+NOPE(connect_unix);
+NOPE(open);
+NOPE(open_socket);
+NOPE(pipe);
+NOPE(tcgetattr);
+NOPE(tcsetattr);
+
+// Stdio.Fd
+NOPE(dup2);
+NOPE(lock); // We could implement this
+NOPE(mode); // We could implement this
+NOPE(proxy); // We could implement this
+NOPE(query_fd);
+NOPE(read_oob);
+NOPE(set_close_on_exec);
+NOPE(set_keepalive);
+NOPE(trylock); // We could implement this
+NOPE(write_oob);
+
+//! @endignore
\ No newline at end of file
diff --git a/tests/examplefiles/ANTLRv3.g b/tests/examplefiles/antlr_ANTLRv3.g
index fbe6d654..fbe6d654 100644
--- a/tests/examplefiles/ANTLRv3.g
+++ b/tests/examplefiles/antlr_ANTLRv3.g
diff --git a/tests/examplefiles/example.e b/tests/examplefiles/example.e
new file mode 100644
index 00000000..2e43954b
--- /dev/null
+++ b/tests/examplefiles/example.e
@@ -0,0 +1,124 @@
+note
+	description : "[
+						This is use to have almost every language element."
+						
+						That way, I can correctly test the lexer. %]"
+						
+						Don't try to understand what it does. It's not even compilling.
+					]"
+	date        : "August 6, 2013"
+	revision    : "0.1"
+
+class
+	SAMPLE
+
+inherit
+	ARGUMENTS
+		rename
+			Command_line as Caller_command,
+			command_name as Application_name
+		undefine
+			out
+		end
+	ANY
+		export
+			{ANY} out
+		redefine
+			out
+		end
+
+
+
+create
+	make
+
+convert
+	as_boolean: {BOOLEAN}
+
+feature {NONE} -- Initialization
+
+	make
+			-- Run application.
+		local
+			i1_:expanded INTEGER
+			f_1:REAL_64
+			l_char:CHARACTER_8
+		do
+			l_char:='!'
+			l_char:='%''
+			l_char:='%%'
+			i1_:=80 - 0x2F0C // 0C70 \\ 0b10110 * 1;
+			f_1:=0.1 / .567
+			f_1:=34.
+			f_1:=12345.67890
+			inspect i1_
+			when 1 then
+				io.output.put_integer (i1_)		-- Comment
+			else
+				io.output.put_real (f_1.truncated_to_real)
+			end
+			io.output.put_string (CuRrEnt.out)		-- Comment
+			(agent funct_1).call([1,2,"Coucou"])
+		end
+
+feature -- Access
+
+	funct_1(x,y:separate INTEGER;a_text:READABLE_STRING_GENERAL):detachable BOOLEAN
+		obsolete "This function is obsolete"
+		require
+			Is_Attached: AttAched a_text
+		local
+			l_list:LIST[like x]
+		do
+			if (NOT a_text.is_empty=TrUe or elSe ((x<0 aNd x>10) oR (y>0 and then y<10))) xor True thEn
+				ResuLT := FalSe
+			elseif (acROss l_list as la_list SoMe	la_list.item<0 end) implies a_text.is_boolean then
+				ResuLT := FalSe
+			else
+				Result := TruE
+			eND
+			from
+				l_list.start
+			until
+				l_list.exhausted
+			loop
+				l_list.forth
+			variant
+				l_list.count - l_list.index
+			end
+			check Current /= Void end
+			debug print("%"Here%"%N") end
+		ensure
+			Is_Cool_Not_Change: is_cool = old is_cool
+		end
+
+	is_cool:BOOLEAN
+		attribute
+			Result:=False
+		end
+
+	froZen c_malloc: POINTER is
+		exTErnal
+			"C inline use <stdlib.h>"
+		alIAs
+			"malloc (1)"
+		end
+
+	as_boolean:BOOLEAN
+		do
+			Result:=True
+		rescue
+			retry
+		end
+
+feature {ANY} -- The redefine feature
+
+	out:STRING_8
+		once
+			reSUlt:=PrecursOr {ANY}
+			Result := "Hello Worl"+('d').out
+		end
+
+invariant
+	Always_Cool: is_cool
+end
diff --git a/tests/examplefiles/example.kal b/tests/examplefiles/example.kal
new file mode 100644
index 00000000..c05c14ca
--- /dev/null
+++ b/tests/examplefiles/example.kal
@@ -0,0 +1,75 @@
+#!/usr/bin/env kal
+
+# This demo executes GET requests in parallel and in series
+# using `for` loops and `wait for` statements.
+
+# Notice how the serial GET requests always return in order
+# and take longer in total. Parallel requests come back in
+# order of receipt.
+
+http = require 'http'
+
+urls = ['http://www.google.com'
+        'http://www.apple.com'
+        'http://www.microsoft.com'
+        'http://www.nodejs.org'
+        'http://www.yahoo.com']
+
+# This function does a GET request for each URL in series
+# It will wait for a response from each request before moving on
+# to the next request. Notice the output will be in the same order as the
+# urls variable every time regardless of response time.
+# It is a task rather than a function because it is called asynchronously
+# This allows us to use `return` to implicitly call back
+task series_demo()
+  # The `series` keyword is optional here (for loops are serial by default)
+  total_time = 0
+
+  for series url in urls
+    timer = new Date
+
+    # we use the `safe` keyword because get is a "nonstandard" task
+    # that does not call back with an error argument
+    safe wait for response from http.get url
+
+    delay = new Date() - timer
+    total_time += delay
+
+    print "GET #{url} - #{response.statusCode} - #{response.connection.bytesRead} bytes - #{delay} ms"
+
+  # because we are in a task rather than a function, this actually exectutes a callback
+  return total_time
+
+# This function does a GET request for each URL in parallel
+# It will NOT wait for a response from each request before moving on
+# to the next request. Notice the output will be determined by the order in which
+# the requests complete!
+task parallel_demo()
+  total_time = 0
+
+  # The `parallel` keyword is only meaningful here because the loop contains
+  # a `wait for` statement (meaning callbacks are used)
+  for parallel url in urls
+    timer = new Date
+
+    # we use the `safe` keyword because get is a "nonstandard" task
+    # that does not call back with an error argument
+    safe wait for response from http.get url
+
+    delay = new Date() - timer
+    total_time += delay
+
+    print "GET #{url} - #{response.statusCode} - #{response.connection.bytesRead} bytes - #{delay}ms"
+
+  # because we are in a task rather than a function, this actually exectutes a callback
+  return total_time
+
+print 'Series Requests...'
+wait for time1 from series_demo()
+print "Total duration #{time1}ms"
+
+print ''
+
+print 'Parallel Requests...'
+wait for time2 from parallel_demo()
+print "Total duration #{time2}ms"
diff --git a/tests/examplefiles/example.ma b/tests/examplefiles/example.ma
new file mode 100644
index 00000000..a8119ea5
--- /dev/null
+++ b/tests/examplefiles/example.ma
@@ -0,0 +1,8 @@
+1 + 1 (* This is a comment *)
+Global`
+SomeNamespace`Foo
+f[x_, y__, 3, z___] := tsneirsnteintie "fosrt" neisnrteiasrn
+E + 3
+Plus[1,Times[2,3]]
+Map[#1 + #2&, SomePairList]
+Plus[1.,-1,-1.,-1.0,]
\ No newline at end of file
diff --git a/tests/examplefiles/example.nix b/tests/examplefiles/example.nix
new file mode 100644
index 00000000..515b686f
--- /dev/null
+++ b/tests/examplefiles/example.nix
@@ -0,0 +1,80 @@
+{ stdenv, fetchurl, fetchgit, openssl, zlib, pcre, libxml2, libxslt, expat
+, rtmp ? false
+, fullWebDAV ? false
+, syslog ? false
+, moreheaders ? false, ...}:
+
+let
+  version = "1.4.4";
+  mainSrc = fetchurl {
+    url = "http://nginx.org/download/nginx-${version}.tar.gz";
+    sha256 = "1f82845mpgmhvm151fhn2cnqjggw9w7cvsqbva9rb320wmc9m63w";
+  };
+
+  rtmp-ext = fetchgit {
+    url = git://github.com/arut/nginx-rtmp-module.git;
+    rev = "1cfb7aeb582789f3b15a03da5b662d1811e2a3f1";
+    sha256 = "03ikfd2l8mzsjwx896l07rdrw5jn7jjfdiyl572yb9jfrnk48fwi";
+  };
+
+  dav-ext = fetchgit {
+    url = git://github.com/arut/nginx-dav-ext-module.git;
+    rev = "54cebc1f21fc13391aae692c6cce672fa7986f9d";
+    sha256 = "1dvpq1fg5rslnl05z8jc39sgnvh3akam9qxfl033akpczq1bh8nq";
+  };
+
+  syslog-ext = fetchgit {
+    url = https://github.com/yaoweibin/nginx_syslog_patch.git;
+    rev = "165affd9741f0e30c4c8225da5e487d33832aca3";
+    sha256 = "14dkkafjnbapp6jnvrjg9ip46j00cr8pqc2g7374z9aj7hrvdvhs";
+  };
+
+  moreheaders-ext = fetchgit {
+    url = https://github.com/agentzh/headers-more-nginx-module.git;
+    rev = "refs/tags/v0.23";
+    sha256 = "12pbjgsxnvcf2ff2i2qdn39q4cm5czlgrng96j8ml4cgxvnbdh39";
+  };
+in
+
+stdenv.mkDerivation rec {
+  name = "nginx-${version}";
+  src = mainSrc;
+
+  buildInputs = [ openssl zlib pcre libxml2 libxslt
+    ] ++ stdenv.lib.optional fullWebDAV expat;
+
+  patches = if syslog then [ "${syslog-ext}/syslog_1.4.0.patch" ] else [];
+
+  configureFlags = [
+    "--with-http_ssl_module"
+    "--with-http_spdy_module"
+    "--with-http_xslt_module"
+    "--with-http_sub_module"
+    "--with-http_dav_module"
+    "--with-http_gzip_static_module"
+    "--with-http_secure_link_module"
+    "--with-ipv6"
+    # Install destination problems
+    # "--with-http_perl_module"
+  ] ++ stdenv.lib.optional rtmp "--add-module=${rtmp-ext}"
+    ++ stdenv.lib.optional fullWebDAV "--add-module=${dav-ext}"
+    ++ stdenv.lib.optional syslog "--add-module=${syslog-ext}"
+    ++ stdenv.lib.optional moreheaders "--add-module=${moreheaders-ext}";
+
+  preConfigure = ''
+    export NIX_CFLAGS_COMPILE="$NIX_CFLAGS_COMPILE -I${libxml2 }/include/libxml2"
+  '';
+
+  # escape example
+  postInstall = ''
+    mv $out/sbin $out/bin ''' ''${
+   ${ if true then ${ "" } else false }
+  '';
+
+  meta = {
+    description = "A reverse proxy and lightweight webserver";
+    maintainers = [ stdenv.lib.maintainers.raskin];
+    platforms = stdenv.lib.platforms.all;
+    inherit version;
+  };
+}
diff --git a/tests/examplefiles/example.stan b/tests/examplefiles/example.stan
index e936f54a..7eb6fdfc 100644
--- a/tests/examplefiles/example.stan
+++ b/tests/examplefiles/example.stan
@@ -19,6 +19,7 @@ data {
   positive_ordered[3] wibble;
   corr_matrix[3] grault;
   cov_matrix[3] garply;
+  cholesky_factor_cov[3] waldo;
   
   real<lower=-1,upper=1> foo1;
   real<lower=0> foo2;
@@ -94,6 +95,7 @@ model {
   // lp__ should be highlighted
   // normal_log as a function
   lp__ <- lp__ + normal_log(plugh, 0, 1);
+  increment_log_prob(normal_log(plugh, 0, 1));
   
   // print statement and string literal
   print("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_~@#$%^&*`'-+={}[].,;: ");
diff --git a/tests/examplefiles/exampleScript.cfc b/tests/examplefiles/exampleScript.cfc
new file mode 100644
index 00000000..002acbcd
--- /dev/null
+++ b/tests/examplefiles/exampleScript.cfc
@@ -0,0 +1,241 @@
+<cfscript>

+/**

+********************************************************************************

+ContentBox - A Modular Content Platform

+Copyright 2012 by Luis Majano and Ortus Solutions, Corp

+www.gocontentbox.org | www.luismajano.com | www.ortussolutions.com

+********************************************************************************

+Apache License, Version 2.0

+

+Copyright Since [2012] [Luis Majano and Ortus Solutions,Corp]

+

+Licensed under the Apache License, Version 2.0 (the "License");

+you may not use this file except in compliance with the License.

+You may obtain a copy of the License at

+

+http://www.apache.org/licenses/LICENSE-2.0

+

+Unless required by applicable law or agreed to in writing, software

+distributed under the License is distributed on an "AS IS" BASIS,

+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+See the License for the specific language governing permissions and

+limitations under the License.

+********************************************************************************

+* A generic content service for content objects

+*/

+component extends="coldbox.system.orm.hibernate.VirtualEntityService" singleton{

+

+	// DI

+	property name="settingService"			inject="id:settingService@cb";

+	property name="cacheBox"				inject="cachebox";

+	property name="log"						inject="logbox:logger:{this}";

+	property name="customFieldService" 	 	inject="customFieldService@cb";

+	property name="categoryService" 	 	inject="categoryService@cb";

+	property name="commentService" 	 		inject="commentService@cb";

+	property name="contentVersionService"	inject="contentVersionService@cb";

+	property name="authorService"			inject="authorService@cb";

+	property name="populator"				inject="wirebox:populator";

+	property name="systemUtil"				inject="SystemUtil@cb";

+	

+	/*

+	* Constructor

+	* @entityName.hint The content entity name to bind this service to.

+	*/

+	ContentService function init(entityName="cbContent"){

+		// init it

+		super.init(entityName=arguments.entityName, useQueryCaching=true);

+

+		// Test scope coloring in pygments

+		this.colorTestVar = "Just for testing pygments!";

+		cookie.colorTestVar = "";

+		client.colorTestVar = ""

+		session.colorTestVar = "";

+		application.colorTestVar = "";

+

+		return this;

+	}

+

+	/**

+	* Clear all content caches

+	* @async.hint Run it asynchronously or not, defaults to false

+	*/

+	function clearAllCaches(boolean async=false){

+		var settings = settingService.getAllSettings(asStruct=true);

+		// Get appropriate cache provider

+		var cache = cacheBox.getCache( settings.cb_content_cacheName );

+		cache.clearByKeySnippet(keySnippet="cb-content",async=arguments.async);

+		return this;

+	}

+

+	/**

+	* Clear all page wrapper caches

+	* @async.hint Run it asynchronously or not, defaults to false

+	*/

+	function clearAllPageWrapperCaches(boolean async=false){

+		var settings = settingService.getAllSettings(asStruct=true);

+		// Get appropriate cache provider

+		var cache = cacheBox.getCache( settings.cb_content_cacheName );

+		cache.clearByKeySnippet(keySnippet="cb-content-pagewrapper",async=arguments.async);

+		return this;

+	}

+

+	/**

+	* Clear all page wrapper caches

+	* @slug.hint The slug partial to clean on

+	* @async.hint Run it asynchronously or not, defaults to false

+	*/

+	function clearPageWrapperCaches(required any slug, boolean async=false){

+		var settings = settingService.getAllSettings(asStruct=true);

+		// Get appropriate cache provider

+		var cache = cacheBox.getCache( settings.cb_content_cacheName );

+		cache.clearByKeySnippet(keySnippet="cb-content-pagewrapper-#arguments.slug#",async=arguments.async);

+		return this;

+	}

+

+	/**

+	* Clear a page wrapper cache

+	* @slug.hint The slug to clean

+	* @async.hint Run it asynchronously or not, defaults to false

+	*/

+	function clearPageWrapper(required any slug, boolean async=false){

+		var settings = settingService.getAllSettings(asStruct=true);

+		// Get appropriate cache provider

+		var cache = cacheBox.getCache( settings.cb_content_cacheName );

+		cache.clear("cb-content-pagewrapper-#arguments.slug#/");

+		return this;

+	}

+

+	/**

+	* Searches published content with cool paramters, remember published content only

+	* @searchTerm.hint The search term to search

+	* @max.hint The maximum number of records to paginate

+	* @offset.hint The offset in the pagination

+	* @asQuery.hint Return as query or array of objects, defaults to array of objects

+	* @sortOrder.hint The sorting of the search results, defaults to publishedDate DESC

+	* @isPublished.hint Search for published, non-published or both content objects [true, false, 'all']

+	* @searchActiveContent.hint Search only content titles or both title and active content. Defaults to both.

+	*/

+	function searchContent(

+		any searchTerm="", 

+		numeric max=0, 

+		numeric offset=0, 

+		boolean asQuery=false, 

+		any sortOrder="publishedDate DESC", 

+		any isPublished=true, 

+		boolean searchActiveContent=true){

+

+		var results = {};

+		var c = newCriteria();

+

+		// only published content

+		if( isBoolean( arguments.isPublished ) ){

+			// Published bit

+			c.isEq( "isPublished", javaCast( "Boolean", arguments.isPublished ) );

+			// Published eq true evaluate other params

+			if( arguments.isPublished ){

+				c.isLt("publishedDate", now() )

+				.$or( c.restrictions.isNull("expireDate"), c.restrictions.isGT("expireDate", now() ) )

+				.isEq("passwordProtection","");

+			}

+		}

+

+		// Search Criteria

+		if( len( arguments.searchTerm ) ){

+			// like disjunctions

+			c.createAlias("activeContent","ac");

+			// Do we search title and active content or just title?

+			if( arguments.searchActiveContent ){

+				c.$or( c.restrictions.like("title","%#arguments.searchTerm#%"),

+				  	  c.restrictions.like("ac.content", "%#arguments.searchTerm#%") );

+			}

+			else{

+				c.like( "title", "%#arguments.searchTerm#%" ); 

+			}

+		}

+

+		// run criteria query and projections count

+		results.count = c.count( "contentID" );

+		results.content = c.resultTransformer( c.DISTINCT_ROOT_ENTITY )

+							.list(offset=arguments.offset, max=arguments.max, sortOrder=arguments.sortOrder, asQuery=arguments.asQuery);

+	

+		return results;

+	}

+

+/********************************************* PRIVATE *********************************************/

+	

+

+	/**

+	* Update the content hits

+	* @contentID.hint The content id to update

+	*/

+	private function syncUpdateHits(required contentID){

+		var q = new Query(sql="UPDATE cb_content SET hits = hits + 1 WHERE contentID = #arguments.contentID#").execute();

+		return this;

+	}

+	

+	

+	private function closureTest(){

+		methodCall(

+			param1,

+			function( arg1, required arg2 ){

+				var settings = settingService.getAllSettings(asStruct=true);

+				// Get appropriate cache provider

+				var cache = cacheBox.getCache( settings.cb_content_cacheName );

+				cache.clear("cb-content-pagewrapper-#arguments.slug#/");

+				return this;

+			},

+			param1

+		);

+	}

+	

+	private function StructliteralTest(){

+		return {

+			foo = bar,

+			brad = 'Wood',

+			func = function( arg1, required arg2 ){

+				var settings = settingService.getAllSettings(asStruct=true);

+				// Get appropriate cache provider

+				var cache = cacheBox.getCache( settings.cb_content_cacheName );

+				cache.clear("cb-content-pagewrapper-#arguments.slug#/");

+				return this;

+			},

+			array = [

+				1,

+				2,

+				3,

+				4,

+				5,

+				'test',

+				'testing',

+				'testerton',

+				{

+					foo = true,

+					brad = false,

+					wood = null

+				}

+			],

+			last = "final"

+		};

+	}

+	

+	private function arrayliteralTest(){

+		return [

+			1,

+			2,

+			3,

+			4,

+			5,

+			'test',

+			'testing',

+			'testerton',

+			{

+				foo = true,

+				brad = false,

+				wood = null

+			},

+			'testy-von-testavich'

+		];

+	}

+	

+}

+</cfscript>
\ No newline at end of file
diff --git a/tests/examplefiles/exampleTag.cfc b/tests/examplefiles/exampleTag.cfc
new file mode 100644
index 00000000..753bb826
--- /dev/null
+++ b/tests/examplefiles/exampleTag.cfc
@@ -0,0 +1,18 @@
+<cfcomponent>

+	

+	<cffunction name="init" access="public" returntype="any">

+		<cfargument name="arg1" type="any" required="true">

+		<cfset this.myVariable = arguments.arg1>

+

+		<cfreturn this>

+	</cffunction>

+

+	<cffunction name="testFunc" access="private" returntype="void">

+		<cfargument name="arg1" type="any" required="false">

+		

+		<cfif structKeyExists(arguments, "arg1")>

+			<cfset writeoutput("Argument exists")>

+		</cfif>

+	</cffunction>

+	

+</cfcomponent>
\ No newline at end of file
diff --git a/tests/examplefiles/example_elixir.ex b/tests/examplefiles/example_elixir.ex
index 2e92163d..e3ce7816 100644
--- a/tests/examplefiles/example_elixir.ex
+++ b/tests/examplefiles/example_elixir.ex
@@ -360,4 +360,6 @@ defmodule Module do
       raise ArgumentError, message:
         "could not call #{fun} on module #{module} because it was already compiled"
   end
-end
\ No newline at end of file
+end
+
+HashDict.new [{'A', 0}, {'T', 0}, {'C', 0}, {'G', 0}]
diff --git a/tests/examplefiles/function_arrows.coffee b/tests/examplefiles/function_arrows.coffee
new file mode 100644
index 00000000..cd1ef1e8
--- /dev/null
+++ b/tests/examplefiles/function_arrows.coffee
@@ -0,0 +1,11 @@
+methodA:-> 'A'
+methodB:=> 'B'
+methodC:()=> 'C'
+methodD:()-> 'D'
+methodE:(a,b)-> 'E'
+methodF:(c,d)-> 'F'
+-> 'G'
+=> 'H'
+
+(-> 'I')
+(=> 'J')
diff --git a/tests/examplefiles/hash_syntax.rb b/tests/examplefiles/hash_syntax.rb
new file mode 100644
index 00000000..35b27723
--- /dev/null
+++ b/tests/examplefiles/hash_syntax.rb
@@ -0,0 +1,5 @@
+{ :old_syntax => 'ok' }
+{ 'stings as key' => 'should be ok' }
+{ new_syntax: 'broken until now' }
+{ withoutunderscore: 'should be ok' }
+{ _underscoreinfront: 'might be ok, if I understand the pygments code correct' }
diff --git a/tests/examplefiles/File.hy b/tests/examplefiles/hybris_File.hy
index 9c86c641..9c86c641 100644
--- a/tests/examplefiles/File.hy
+++ b/tests/examplefiles/hybris_File.hy
diff --git a/tests/examplefiles/mg_sample.pro b/tests/examplefiles/idl_sample.pro
index 814d510d..814d510d 100644
--- a/tests/examplefiles/mg_sample.pro
+++ b/tests/examplefiles/idl_sample.pro
diff --git a/tests/examplefiles/inet_pton6.dg b/tests/examplefiles/inet_pton6.dg
index 4104b3e7..3813d5b8 100644
--- a/tests/examplefiles/inet_pton6.dg
+++ b/tests/examplefiles/inet_pton6.dg
@@ -1,5 +1,5 @@
-re  = import!
-sys = import!
+import '/re'
+import '/sys'
 
 
 # IPv6address    =  hexpart [ ":" IPv4address ]
@@ -20,7 +20,7 @@ addrv6  = re.compile $ r'(?i)(?:{})(?::{})?$'.format hexpart addrv4
 #
 # :return: a decimal integer
 #
-base_n = (q digits) -> foldl (x y) -> (x * q + y) 0 digits
+base_n = q digits -> foldl (x y -> x * q + y) 0 digits
 
 
 # Parse a sequence of hexadecimal numbers
@@ -29,7 +29,7 @@ base_n = (q digits) -> foldl (x y) -> (x * q + y) 0 digits
 #
 # :return: an iterable of Python ints
 #
-unhex = q -> q and map p -> (int p 16) (q.split ':')
+unhex = q -> q and map (p -> int p 16) (q.split ':')
 
 
 # Parse an IPv6 address as specified in RFC 4291.
@@ -39,33 +39,33 @@ unhex = q -> q and map p -> (int p 16) (q.split ':')
 # :return: an integer which, written in binary form, points to the same node.
 #
 inet_pton6 = address ->
-  raise $ ValueError 'not a valid IPv6 address' if not (match = addrv6.match address)
+  not (match = addrv6.match address) => raise $ ValueError 'not a valid IPv6 address'
   start, end, *ipv4 = match.groups!
 
   is_ipv4 = not $ None in ipv4
   shift   = (7 - start.count ':' - 2 * is_ipv4) * 16
 
-  raise $ ValueError 'not a valid IPv6 address' if (end is None and shift) or shift < 0
+  (end is None and shift) or shift < 0 => raise $ ValueError 'not a valid IPv6 address'
   hexaddr = (base_n 0x10000 (unhex start) << shift) + base_n 0x10000 (unhex $ end or '')
-  (hexaddr << 32) + base_n 0x100 (map int ipv4) if is_ipv4 else hexaddr
+  if (is_ipv4 => (hexaddr << 32) + base_n 0x100 (map int ipv4)) (otherwise => hexaddr)
 
 
-inet6_type = q -> switch
-  not q = 'unspecified'
-  q == 1 = 'loopback'
-  (q >>  32)              == 0x000000000000ffff = 'IPv4-mapped'
-  (q >>  64)              == 0xfe80000000000000 = 'link-local'
-  (q >> 120)              != 0x00000000000000ff = 'general unicast'
-  (q >> 112) % (1 << 4)   == 0x0000000000000000 = 'multicast w/ reserved scope value'
-  (q >> 112) % (1 << 4)   == 0x000000000000000f = 'multicast w/ reserved scope value'
-  (q >> 112) % (1 << 4)   == 0x0000000000000001 = 'interface-local multicast'
-  (q >> 112) % (1 << 4)   == 0x0000000000000004 = 'admin-local multicast'
-  (q >> 112) % (1 << 4)   == 0x0000000000000005 = 'site-local multicast'
-  (q >> 112) % (1 << 4)   == 0x0000000000000008 = 'organization-local multicast'
-  (q >> 112) % (1 << 4)   == 0x000000000000000e = 'global multicast'
-  (q >> 112) % (1 << 4)   != 0x0000000000000002 = 'multicast w/ unknown scope value'
-  (q >>  24) % (1 << 112) == 0x00000000000001ff = 'solicited-node multicast'
-  True = 'link-local multicast'
+inet6_type = q -> if
+  q == 0 => 'unspecified'
+  q == 1 => 'loopback'
+  (q >>  32)              == 0x000000000000ffff => 'IPv4-mapped'
+  (q >>  64)              == 0xfe80000000000000 => 'link-local'
+  (q >> 120)              != 0x00000000000000ff => 'general unicast'
+  (q >> 112) % (1 << 4)   == 0x0000000000000000 => 'multicast w/ reserved scope value'
+  (q >> 112) % (1 << 4)   == 0x000000000000000f => 'multicast w/ reserved scope value'
+  (q >> 112) % (1 << 4)   == 0x0000000000000001 => 'interface-local multicast'
+  (q >> 112) % (1 << 4)   == 0x0000000000000004 => 'admin-local multicast'
+  (q >> 112) % (1 << 4)   == 0x0000000000000005 => 'site-local multicast'
+  (q >> 112) % (1 << 4)   == 0x0000000000000008 => 'organization-local multicast'
+  (q >> 112) % (1 << 4)   == 0x000000000000000e => 'global multicast'
+  (q >> 112) % (1 << 4)   != 0x0000000000000002 => 'multicast w/ unknown scope value'
+  (q >>  24) % (1 << 112) == 0x00000000000001ff => 'solicited-node multicast'
+  otherwise => 'link-local multicast'
 
 
-print $ (x -> (inet6_type x, hex x)) $ inet_pton6 $ sys.stdin.read!.strip!
+print $ (x -> inet6_type x, hex x) $ inet_pton6 $ sys.stdin.read!.strip!
diff --git a/tests/examplefiles/language.hy b/tests/examplefiles/language.hy
new file mode 100644
index 00000000..9768c39c
--- /dev/null
+++ b/tests/examplefiles/language.hy
@@ -0,0 +1,165 @@
+;;;; This contains some of the core Hy functions used
+;;;; to make functional programming slightly easier.
+;;;;
+
+
+(defn _numeric-check [x]
+  (if (not (numeric? x))
+    (raise (TypeError (.format "{0!r} is not a number" x)))))
+
+(defn cycle [coll]
+  "Yield an infinite repetition of the items in coll"
+  (setv seen [])
+  (for [x coll]
+    (yield x)
+    (.append seen x))
+  (while seen
+    (for [x seen]
+      (yield x))))
+
+(defn dec [n]
+  "Decrement n by 1"
+  (_numeric-check n)
+  (- n 1))
+
+(defn distinct [coll]
+  "Return a generator from the original collection with duplicates
+   removed"
+  (let [[seen []] [citer (iter coll)]]
+    (for [val citer]
+      (if (not_in val seen)
+        (do
+         (yield val)
+         (.append seen val))))))
+
+(defn drop [count coll]
+  "Drop `count` elements from `coll` and yield back the rest"
+  (let [[citer (iter coll)]]
+    (try (for [i (range count)]
+           (next citer))
+         (catch [StopIteration]))
+    citer))
+
+(defn even? [n]
+  "Return true if n is an even number"
+  (_numeric-check n)
+  (= (% n 2) 0))
+
+(defn filter [pred coll]
+  "Return all elements from `coll` that pass `pred`"
+  (let [[citer (iter coll)]]
+    (for [val citer]
+      (if (pred val)
+        (yield val)))))
+
+(defn inc [n]
+  "Increment n by 1"
+  (_numeric-check n)
+  (+ n 1))
+
+(defn instance? [klass x]
+  (isinstance x klass))
+
+(defn iterable? [x]
+  "Return true if x is iterable"
+  (try (do (iter x) true)
+       (catch [Exception] false)))
+
+(defn iterate [f x]
+  (setv val x)
+  (while true
+    (yield val)
+    (setv val (f val))))
+
+(defn iterator? [x]
+  "Return true if x is an iterator"
+  (try (= x (iter x))
+       (catch [TypeError] false)))
+
+(defn neg? [n]
+  "Return true if n is < 0"
+  (_numeric-check n)
+  (< n 0))
+
+(defn none? [x]
+  "Return true if x is None"
+  (is x None))
+
+(defn numeric? [x]
+  (import numbers)
+  (instance? numbers.Number x))
+
+(defn nth [coll index]
+  "Return nth item in collection or sequence, counting from 0"
+  (if (not (neg? index))
+    (if (iterable? coll)
+      (try (first (list (take 1 (drop index coll))))
+           (catch [IndexError] None))
+      (try (get coll index)
+           (catch [IndexError] None)))
+    None))
+
+(defn odd? [n]
+  "Return true if n is an odd number"
+  (_numeric-check n)
+  (= (% n 2) 1))
+
+(defn pos? [n]
+  "Return true if n is > 0"
+  (_numeric_check n)
+  (> n 0))
+
+(defn remove [pred coll]
+  "Return coll with elements removed that pass `pred`"
+  (let [[citer (iter coll)]]
+    (for [val citer]
+      (if (not (pred val))
+        (yield val)))))
+
+(defn repeat [x &optional n]
+  "Yield x forever or optionally n times"
+  (if (none? n)
+    (setv dispatch (fn [] (while true (yield x))))
+    (setv dispatch (fn [] (for [_ (range n)] (yield x)))))
+  (dispatch))
+
+(defn repeatedly [func]
+  "Yield result of running func repeatedly"
+  (while true
+    (yield (func))))
+
+(defn take [count coll]
+  "Take `count` elements from `coll`, or the whole set if the total
+    number of entries in `coll` is less than `count`."
+  (let [[citer (iter coll)]]
+    (for [_ (range count)]
+      (yield (next citer)))))
+
+(defn take-nth [n coll]
+  "Return every nth member of coll
+     raises ValueError for (not (pos? n))"
+  (if (pos? n)
+    (let [[citer (iter coll)] [skip (dec n)]]
+      (for [val citer]
+        (yield val)
+        (for [_ (range skip)]
+          (next citer))))
+    (raise (ValueError "n must be positive"))))
+
+(defn take-while [pred coll]
+  "Take all elements while `pred` is true"
+  (let [[citer (iter coll)]]
+    (for [val citer]
+      (if (pred val)
+        (yield val)
+        (break)))))
+
+(defn zero? [n]
+  "Return true if n is 0"
+  (_numeric_check n)
+  (= n 0))
+
+(def *exports* ["cycle" "dec" "distinct" "drop" "even?" "filter" "inc"
+                "instance?" "iterable?" "iterate" "iterator?" "neg?"
+                "none?" "nth" "numeric?" "odd?" "pos?" "remove" "repeat"
+                "repeatedly" "take" "take_nth" "take_while" "zero?"])
diff --git a/tests/examplefiles/livescript-demo.ls b/tests/examplefiles/livescript-demo.ls
index 2ff68c63..16d1894a 100644
--- a/tests/examplefiles/livescript-demo.ls
+++ b/tests/examplefiles/livescript-demo.ls
@@ -9,6 +9,8 @@ underscores_i$d = ->
   //regexp2//g
   'strings' and "strings" and \strings
 
+another-word-list = <[ more words ]>
+
 [2 til 10]
   |> map (* 2)
   |> filter (> 5)
diff --git a/tests/examplefiles/robotframework.txt b/tests/examplefiles/robotframework_test.txt
index 63ba63e6..63ba63e6 100644
--- a/tests/examplefiles/robotframework.txt
+++ b/tests/examplefiles/robotframework_test.txt
diff --git a/tests/examplefiles/scope.cirru b/tests/examplefiles/scope.cirru
new file mode 100644
index 00000000..b17ff4ea
--- /dev/null
+++ b/tests/examplefiles/scope.cirru
@@ -0,0 +1,37 @@
+
+-- https://github.com/Cirru/cirru-gopher/blob/master/code/scope.cr
+
+set a (int 2)
+
+print (self)
+
+set c (child)
+
+under c
+  under parent
+    print a
+
+print $ get c a
+
+set c x (int 3)
+print $ get c x
+
+set just-print $ code
+  print a
+
+print just-print
+
+eval (self) just-print
+eval just-print
+
+print (string "string with space")
+print (string "escapes \n \"\\")
+
+brackets ((((()))))
+
+"eval" $ string "eval"
+
+print (add $ (int 1) (int 2))
+
+print $ unwrap $
+  map (a $ int 1) (b $ int 2)
\ No newline at end of file
diff --git a/tests/examplefiles/test.bas b/tests/examplefiles/vbnet_test.bas
index af5f2574..af5f2574 100644
--- a/tests/examplefiles/test.bas
+++ b/tests/examplefiles/vbnet_test.bas
diff --git a/tests/old_run.py b/tests/old_run.py
deleted file mode 100644
index 4f7cef16..00000000
--- a/tests/old_run.py
+++ /dev/null
@@ -1,138 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Pygments unit tests
-    ~~~~~~~~~~~~~~~~~~
-
-    Usage::
-
-        python run.py [testfile ...]
-
-
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import sys, os
-import unittest
-
-from os.path import dirname, basename, join, abspath
-
-import pygments
-
-try:
-    import coverage
-except ImportError:
-    coverage = None
-
-testdir = abspath(dirname(__file__))
-
-failed = []
-total_test_count = 0
-error_test_count = 0
-
-
-def err(file, what, exc):
-    print >>sys.stderr, file, 'failed %s:' % what,
-    print >>sys.stderr, exc
-    failed.append(file[:-3])
-
-
-class QuietTestRunner(object):
-    """Customized test runner for relatively quiet output"""
-
-    def __init__(self, testname, stream=sys.stderr):
-        self.testname = testname
-        self.stream = unittest._WritelnDecorator(stream)
-
-    def run(self, test):
-        global total_test_count
-        global error_test_count
-        result = unittest._TextTestResult(self.stream, True, 1)
-        test(result)
-        if not result.wasSuccessful():
-            self.stream.write(' FAIL:')
-            result.printErrors()
-            failed.append(self.testname)
-        else:
-            self.stream.write(' ok\n')
-        total_test_count += result.testsRun
-        error_test_count += len(result.errors) + len(result.failures)
-        return result
-
-
-def run_tests(with_coverage=False):
-    # needed to avoid confusion involving atexit handlers
-    import logging
-
-    if sys.argv[1:]:
-        # test only files given on cmdline
-        files = [entry + '.py' for entry in sys.argv[1:] if entry.startswith('test_')]
-    else:
-        files = [entry for entry in os.listdir(testdir)
-                 if (entry.startswith('test_') and entry.endswith('.py'))]
-        files.sort()
-
-    WIDTH = 85
-
-    print >>sys.stderr, \
-        ('Pygments %s Test Suite running%s, stand by...' %
-         (pygments.__version__,
-          with_coverage and " with coverage analysis" or "")).center(WIDTH)
-    print >>sys.stderr, ('(using Python %s)' % sys.version.split()[0]).center(WIDTH)
-    print >>sys.stderr, '='*WIDTH
-
-    if with_coverage:
-        coverage.erase()
-        coverage.start()
-
-    for testfile in files:
-        globs = {'__file__': join(testdir, testfile)}
-        try:
-            execfile(join(testdir, testfile), globs)
-        except Exception, exc:
-            raise
-            err(testfile, 'execfile', exc)
-            continue
-        sys.stderr.write(testfile[:-3] + ': ')
-        try:
-            runner = QuietTestRunner(testfile[:-3])
-            # make a test suite of all TestCases in the file
-            tests = []
-            for name, thing in globs.iteritems():
-                if name.endswith('Test'):
-                    tests.append((name, unittest.makeSuite(thing)))
-            tests.sort()
-            suite = unittest.TestSuite()
-            suite.addTests([x[1] for x in tests])
-            runner.run(suite)
-        except Exception, exc:
-            err(testfile, 'running test', exc)
-
-    print >>sys.stderr, '='*WIDTH
-    if failed:
-        print >>sys.stderr, '%d of %d tests failed.' % \
-              (error_test_count, total_test_count)
-        print >>sys.stderr, 'Tests failed in:', ', '.join(failed)
-        ret = 1
-    else:
-        if total_test_count == 1:
-            print >>sys.stderr, '1 test happy.'
-        else:
-            print >>sys.stderr, 'All %d tests happy.' % total_test_count
-        ret = 0
-
-    if with_coverage:
-        coverage.stop()
-        modules = [mod for name, mod in sys.modules.iteritems()
-                   if name.startswith('pygments.') and mod]
-        coverage.report(modules)
-
-    return ret
-
-
-if __name__ == '__main__':
-    with_coverage = False
-    if sys.argv[1:2] == ['-C']:
-        with_coverage = bool(coverage)
-        del sys.argv[1]
-    sys.exit(run_tests(with_coverage))
diff --git a/tests/run.py b/tests/run.py
index 18a1d824..e87837e5 100644
--- a/tests/run.py
+++ b/tests/run.py
@@ -8,42 +8,37 @@
         python run.py [testfile ...]
 
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
+from __future__ import print_function
+
 import sys, os
 
-if sys.version_info >= (3,):
-    # copy test suite over to "build/lib" and convert it
-    print ('Copying and converting sources to build/lib/test...')
-    from distutils.util import copydir_run_2to3
-    testroot = os.path.dirname(__file__)
-    newroot = os.path.join(testroot, '..', 'build/lib/test')
-    copydir_run_2to3(testroot, newroot)
-    # make nose believe that we run from the converted dir
-    os.chdir(newroot)
-else:
-    # only find tests in this directory
-    if os.path.dirname(__file__):
-        os.chdir(os.path.dirname(__file__))
+# only find tests in this directory
+if os.path.dirname(__file__):
+    os.chdir(os.path.dirname(__file__))
 
 
 try:
     import nose
 except ImportError:
-    print ('nose is required to run the Pygments test suite')
+    print('nose is required to run the Pygments test suite')
     sys.exit(1)
 
 try:
     # make sure the current source is first on sys.path
     sys.path.insert(0, '..')
     import pygments
-except ImportError:
-    print ('Cannot find Pygments to test: %s' % sys.exc_info()[1])
+except SyntaxError as err:
+    print('Syntax error: %s' % err)
+    sys.exit(1)
+except ImportError as err:
+    print('Cannot find Pygments to test: %s' % err)
     sys.exit(1)
 else:
-    print ('Pygments %s test suite running (Python %s)...' %
-           (pygments.__version__, sys.version.split()[0]))
+    print('Pygments %s test suite running (Python %s)...' %
+          (pygments.__version__, sys.version.split()[0]))
 
 nose.main()
diff --git a/tests/test_basic_api.py b/tests/test_basic_api.py
index 18ed8d64..78227d2f 100644
--- a/tests/test_basic_api.py
+++ b/tests/test_basic_api.py
@@ -3,11 +3,12 @@
     Pygments basic API tests
     ~~~~~~~~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-import os
+from __future__ import print_function
+
 import random
 import unittest
 
@@ -15,7 +16,7 @@ from pygments import lexers, formatters, filters, format
 from pygments.token import _TokenType, Text
 from pygments.lexer import RegexLexer
 from pygments.formatters.img import FontNotFound
-from pygments.util import BytesIO, StringIO, bytes, b
+from pygments.util import text_type, StringIO, xrange
 
 import support
 
@@ -28,7 +29,7 @@ test_content = ''.join(test_content) + '\n'
 
 def test_lexer_import_all():
     # instantiate every lexer, to see if the token type defs are correct
-    for x in lexers.LEXERS.keys():
+    for x in lexers.LEXERS:
         c = getattr(lexers, x)()
 
 
@@ -45,6 +46,8 @@ def test_lexer_classes():
         result = cls.analyse_text(".abc")
         assert isinstance(result, float) and 0.0 <= result <= 1.0
 
+        assert all(al.lower() == al for al in cls.aliases)
+
         inst = cls(opt1="val1", opt2="val2")
         if issubclass(cls, RegexLexer):
             if not hasattr(cls, '_tokens'):
@@ -60,14 +63,17 @@ def test_lexer_classes():
         if cls.name in ['XQuery', 'Opa']:   # XXX temporary
             return
 
-        tokens = list(inst.get_tokens(test_content))
+        try:
+            tokens = list(inst.get_tokens(test_content))
+        except KeyboardInterrupt:
+            raise KeyboardInterrupt('interrupted %s.get_tokens(): test_content=%r' % (cls.__name__, test_content))
         txt = ""
         for token in tokens:
             assert isinstance(token, tuple)
             assert isinstance(token[0], _TokenType)
             if isinstance(token[1], str):
-                print repr(token[1])
-            assert isinstance(token[1], unicode)
+                print(repr(token[1]))
+            assert isinstance(token[1], text_type)
             txt += token[1]
         assert txt == test_content, "%s lexer roundtrip failed: %r != %r" % \
                (cls.name, test_content, txt)
@@ -122,7 +128,7 @@ def test_get_lexers():
                        ]:
         yield verify, func, args
 
-    for cls, (_, lname, aliases, _, mimetypes) in lexers.LEXERS.iteritems():
+    for cls, (_, lname, aliases, _, mimetypes) in lexers.LEXERS.items():
         assert cls == lexers.find_lexer_class(lname).__name__
 
         for alias in aliases:
@@ -157,7 +163,7 @@ def test_formatter_public_api():
             pass
         inst.format(ts, out)
 
-    for formatter, info in formatters.FORMATTERS.iteritems():
+    for formatter, info in formatters.FORMATTERS.items():
         yield verify, formatter, info
 
 def test_formatter_encodings():
@@ -167,7 +173,7 @@ def test_formatter_encodings():
     fmt = HtmlFormatter()
     tokens = [(Text, u"ä")]
     out = format(tokens, fmt)
-    assert type(out) is unicode
+    assert type(out) is text_type
     assert u"ä" in out
 
     # encoding option
@@ -196,7 +202,7 @@ def test_formatter_unicode_handling():
         if formatter.name != 'Raw tokens':
             out = format(tokens, inst)
             if formatter.unicodeoutput:
-                assert type(out) is unicode
+                assert type(out) is text_type
 
             inst = formatter(encoding='utf-8')
             out = format(tokens, inst)
@@ -208,7 +214,7 @@ def test_formatter_unicode_handling():
             out = format(tokens, inst)
             assert type(out) is bytes, '%s: %r' % (formatter, out)
 
-    for formatter, info in formatters.FORMATTERS.iteritems():
+    for formatter, info in formatters.FORMATTERS.items():
         yield verify, formatter
 
 
@@ -236,7 +242,7 @@ class FiltersTest(unittest.TestCase):
             'whitespace': {'spaces': True, 'tabs': True, 'newlines': True},
             'highlight': {'names': ['isinstance', 'lexers', 'x']},
         }
-        for x in filters.FILTERS.keys():
+        for x in filters.FILTERS:
             lx = lexers.PythonLexer()
             lx.add_filter(x, **filter_args.get(x, {}))
             fp = open(TESTFILE, 'rb')
diff --git a/tests/test_clexer.py b/tests/test_clexer.py
index 8b37bf57..c995bb2b 100644
--- a/tests/test_clexer.py
+++ b/tests/test_clexer.py
@@ -3,7 +3,7 @@
     Basic CLexer Test
     ~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
diff --git a/tests/test_cmdline.py b/tests/test_cmdline.py
index 5ad815c0..ef14661c 100644
--- a/tests/test_cmdline.py
+++ b/tests/test_cmdline.py
@@ -3,17 +3,18 @@
     Command line test
     ~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 # Test the command line interface
 
-import sys, os
+import io
+import sys
 import unittest
-import StringIO
 
 from pygments import highlight
+from pygments.util import StringIO
 from pygments.cmdline import main as cmdline_main
 
 import support
@@ -24,8 +25,8 @@ TESTFILE, TESTDIR = support.location(__file__)
 def run_cmdline(*args):
     saved_stdout = sys.stdout
     saved_stderr = sys.stderr
-    new_stdout = sys.stdout = StringIO.StringIO()
-    new_stderr = sys.stderr = StringIO.StringIO()
+    new_stdout = sys.stdout = StringIO()
+    new_stderr = sys.stderr = StringIO()
     try:
         ret = cmdline_main(["pygmentize"] + list(args))
     finally:
diff --git a/tests/test_examplefiles.py b/tests/test_examplefiles.py
index d785cf3b..0547ffd3 100644
--- a/tests/test_examplefiles.py
+++ b/tests/test_examplefiles.py
@@ -3,18 +3,20 @@
     Pygments tests with example files
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
+from __future__ import print_function
+
 import os
 import pprint
 import difflib
-import cPickle as pickle
+import pickle
 
 from pygments.lexers import get_lexer_for_filename, get_lexer_by_name
 from pygments.token import Error
-from pygments.util import ClassNotFound, b
+from pygments.util import ClassNotFound
 
 STORE_OUTPUT = False
 
@@ -31,21 +33,30 @@ def test_example_files():
         absfn = os.path.join(testdir, 'examplefiles', fn)
         if not os.path.isfile(absfn):
             continue
-        outfn = os.path.join(outdir, fn)
 
+        print(absfn)
+        code = open(absfn, 'rb').read()
         try:
-            lx = get_lexer_for_filename(absfn)
-        except ClassNotFound:
-            if "_" not in fn:
+            code = code.decode('utf-8')
+        except UnicodeError:
+            code = code.decode('latin1')
+
+        outfn = os.path.join(outdir, fn)
+
+        lx = None
+        if '_' in fn:
+            try:
+                lx = get_lexer_by_name(fn.split('_')[0])
+            except ClassNotFound:
+                pass
+        if lx is None:
+            try:
+                lx = get_lexer_for_filename(absfn, code=code)
+            except ClassNotFound:
                 raise AssertionError('file %r has no registered extension, '
                                      'nor is of the form <lexer>_filename '
                                      'for overriding, thus no lexer found.'
-                                    % fn)
-            try:
-                name, rest = fn.split("_", 1)
-                lx = get_lexer_by_name(name)
-            except ClassNotFound:
-                raise AssertionError('no lexer found for file %r' % fn)
+                                     % fn)
         yield check_lexer, lx, absfn, outfn
 
 def check_lexer(lx, absfn, outfn):
@@ -54,8 +65,8 @@ def check_lexer(lx, absfn, outfn):
         text = fp.read()
     finally:
         fp.close()
-    text = text.replace(b('\r\n'), b('\n'))
-    text = text.strip(b('\n')) + b('\n')
+    text = text.replace(b'\r\n', b'\n')
+    text = text.strip(b'\n') + b'\n'
     try:
         text = text.decode('utf-8')
         if text.startswith(u'\ufeff'):
@@ -71,8 +82,8 @@ def check_lexer(lx, absfn, outfn):
             (lx, absfn, val, len(u''.join(ntext)))
         tokens.append((type, val))
     if u''.join(ntext) != text:
-        print '\n'.join(difflib.unified_diff(u''.join(ntext).splitlines(),
-                                             text.splitlines()))
+        print('\n'.join(difflib.unified_diff(u''.join(ntext).splitlines(),
+                                             text.splitlines())))
         raise AssertionError('round trip failed for ' + absfn)
 
     # check output against previous run if enabled
@@ -94,6 +105,6 @@ def check_lexer(lx, absfn, outfn):
         if stored_tokens != tokens:
             f1 = pprint.pformat(stored_tokens)
             f2 = pprint.pformat(tokens)
-            print '\n'.join(difflib.unified_diff(f1.splitlines(),
-                                                 f2.splitlines()))
+            print('\n'.join(difflib.unified_diff(f1.splitlines(),
+                                                 f2.splitlines())))
             assert False, absfn
diff --git a/tests/test_html_formatter.py b/tests/test_html_formatter.py
index f7e7a542..91225cd3 100644
--- a/tests/test_html_formatter.py
+++ b/tests/test_html_formatter.py
@@ -3,27 +3,29 @@
     Pygments HTML formatter tests
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
+from __future__ import print_function
+
+import io
 import os
 import re
 import unittest
-import StringIO
 import tempfile
 from os.path import join, dirname, isfile
 
+from pygments.util import StringIO
 from pygments.lexers import PythonLexer
 from pygments.formatters import HtmlFormatter, NullFormatter
 from pygments.formatters.html import escape_html
-from pygments.util import uni_open
 
 import support
 
 TESTFILE, TESTDIR = support.location(__file__)
 
-fp = uni_open(TESTFILE, encoding='utf-8')
+fp = io.open(TESTFILE, encoding='utf-8')
 try:
     tokensource = list(PythonLexer().get_tokens(fp.read()))
 finally:
@@ -33,11 +35,11 @@ finally:
 class HtmlFormatterTest(unittest.TestCase):
     def test_correct_output(self):
         hfmt = HtmlFormatter(nowrap=True)
-        houtfile = StringIO.StringIO()
+        houtfile = StringIO()
         hfmt.format(tokensource, houtfile)
 
         nfmt = NullFormatter()
-        noutfile = StringIO.StringIO()
+        noutfile = StringIO()
         nfmt.format(tokensource, noutfile)
 
         stripped_html = re.sub('<.*?>', '', houtfile.getvalue())
@@ -74,13 +76,13 @@ class HtmlFormatterTest(unittest.TestCase):
                         dict(linenos=True, full=True),
                         dict(linenos=True, full=True, noclasses=True)]:
 
-            outfile = StringIO.StringIO()
+            outfile = StringIO()
             fmt = HtmlFormatter(**optdict)
             fmt.format(tokensource, outfile)
 
     def test_linenos(self):
         optdict = dict(linenos=True)
-        outfile = StringIO.StringIO()
+        outfile = StringIO()
         fmt = HtmlFormatter(**optdict)
         fmt.format(tokensource, outfile)
         html = outfile.getvalue()
@@ -88,7 +90,7 @@ class HtmlFormatterTest(unittest.TestCase):
 
     def test_linenos_with_startnum(self):
         optdict = dict(linenos=True, linenostart=5)
-        outfile = StringIO.StringIO()
+        outfile = StringIO()
         fmt = HtmlFormatter(**optdict)
         fmt.format(tokensource, outfile)
         html = outfile.getvalue()
@@ -96,7 +98,7 @@ class HtmlFormatterTest(unittest.TestCase):
 
     def test_lineanchors(self):
         optdict = dict(lineanchors="foo")
-        outfile = StringIO.StringIO()
+        outfile = StringIO()
         fmt = HtmlFormatter(**optdict)
         fmt.format(tokensource, outfile)
         html = outfile.getvalue()
@@ -104,7 +106,7 @@ class HtmlFormatterTest(unittest.TestCase):
 
     def test_lineanchors_with_startnum(self):
         optdict = dict(lineanchors="foo", linenostart=5)
-        outfile = StringIO.StringIO()
+        outfile = StringIO()
         fmt = HtmlFormatter(**optdict)
         fmt.format(tokensource, outfile)
         html = outfile.getvalue()
@@ -132,7 +134,7 @@ class HtmlFormatterTest(unittest.TestCase):
             pass
         else:
             if ret:
-                print output
+                print(output)
             self.assertFalse(ret, 'nsgmls run reported errors')
 
         os.unlink(pathname)
@@ -172,7 +174,7 @@ class HtmlFormatterTest(unittest.TestCase):
             # anymore in the actual source
             fmt = HtmlFormatter(tagsfile='support/tags', lineanchors='L',
                                 tagurlformat='%(fname)s%(fext)s')
-            outfile = StringIO.StringIO()
+            outfile = StringIO()
             fmt.format(tokensource, outfile)
             self.assertTrue('<a href="test_html_formatter.py#L-165">test_ctags</a>'
                             in outfile.getvalue())
diff --git a/tests/test_latex_formatter.py b/tests/test_latex_formatter.py
index 06a74c3d..13ae87cd 100644
--- a/tests/test_latex_formatter.py
+++ b/tests/test_latex_formatter.py
@@ -3,10 +3,12 @@
     Pygments LaTeX formatter tests
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
+from __future__ import print_function
+
 import os
 import unittest
 import tempfile
@@ -48,7 +50,7 @@ class LatexFormatterTest(unittest.TestCase):
             pass
         else:
             if ret:
-                print output
+                print(output)
             self.assertFalse(ret, 'latex run reported errors')
 
         os.unlink(pathname)
diff --git a/tests/test_lexers_other.py b/tests/test_lexers_other.py
index d3cfa246..1e420c77 100644
--- a/tests/test_lexers_other.py
+++ b/tests/test_lexers_other.py
@@ -3,7 +3,7 @@
     Tests for other lexers
     ~~~~~~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -28,7 +28,7 @@ class AnalyseTextTest(unittest.TestCase):
             for exampleFilePath in glob.glob(exampleFilesPattern):
                 exampleFile = open(exampleFilePath, 'rb')
                 try:
-                    text = exampleFile.read()
+                    text = exampleFile.read().decode('utf-8')
                     probability = lexer.analyse_text(text)
                     self.assertTrue(probability > 0,
                         '%s must recognize %r' % (
diff --git a/tests/test_perllexer.py b/tests/test_perllexer.py
index 315b20e3..bfa3aeb8 100644
--- a/tests/test_perllexer.py
+++ b/tests/test_perllexer.py
@@ -3,7 +3,7 @@
     Pygments regex lexer tests
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
diff --git a/tests/test_regexlexer.py b/tests/test_regexlexer.py
index 28d9689b..b12dce0a 100644
--- a/tests/test_regexlexer.py
+++ b/tests/test_regexlexer.py
@@ -3,7 +3,7 @@
     Pygments regex lexer tests
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
diff --git a/tests/test_token.py b/tests/test_token.py
index 6a5b00b7..c5cc4990 100644
--- a/tests/test_token.py
+++ b/tests/test_token.py
@@ -3,7 +3,7 @@
     Test suite for the token module
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -36,11 +36,11 @@ class TokenTest(unittest.TestCase):
         stp = token.STANDARD_TYPES.copy()
         stp[token.Token] = '---' # Token and Text do conflict, that is okay
         t = {}
-        for k, v in stp.iteritems():
+        for k, v in stp.items():
             t.setdefault(v, []).append(k)
         if len(t) == len(stp):
             return # Okay
 
-        for k, v in t.iteritems():
+        for k, v in t.items():
             if len(v) > 1:
                 self.fail("%r has more than one key: %r" % (k, v))
diff --git a/tests/test_using_api.py b/tests/test_using_api.py
index bb89d1e2..9e53c206 100644
--- a/tests/test_using_api.py
+++ b/tests/test_using_api.py
@@ -3,7 +3,7 @@
     Pygments tests for using()
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
diff --git a/tests/test_util.py b/tests/test_util.py
index dbbc66ce..59ecf14f 100644
--- a/tests/test_util.py
+++ b/tests/test_util.py
@@ -3,7 +3,7 @@
     Test suite for the util module
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """