mathml 0.8.0

data/test/math_ml_test_util.rb

@@ -0,0 +1,48 @@
+# Utility for tests
+#
+# Copyright (C) 2006, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+
+class Symbol
+	def <=>(s)
+		self.to_s<=>s.to_s
+	end
+end
+class Hash
+	def each
+		keys.sort.each do |k|
+			yield(k, self[k])
+		end
+	end
+end
+
+module Util4TC_MathML
+	def setup
+		@p = MathML::LaTeX::Parser.new unless @p
+		super
+	end
+
+	def strip(str)
+		str.gsub(/>\s*/, ">").gsub(/\s*</, "<")
+	end
+
+	def strip_mathml(mathml)
+		strip(mathml)[/\A<math [^>]*>(.*)<\/math>\Z/m, 1]
+	end
+
+	def smml(str, display_style=false, p=nil)
+		p = @p unless p
+		mml = p.parse(str, display_style).to_s
+		strip_mathml(mml)
+	end
+
+	def parse_error(e)
+		[e.message, e.done, e.rest].flatten
+	end
+
+	def assert_parse_error(message=nil, done=nil, rest=nil, write=false)
+		e = assert_raises(MathML::LaTeX::ParseError){yield}
+		puts e.inspect if write
+		assert_equal([message, done, rest], parse_error(e))
+	end
+end

data/test/math_ml_test_util_test.rb

@@ -0,0 +1,22 @@
+# Test for test_util
+#
+# Copyright (C) 2006, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+
+require "test/unit"
+require "test/math_ml_test_util"
+require "math_ml"
+
+class TC_Util4TC_MathML < Test::Unit::TestCase
+	include Util4TC_MathML
+
+	def test_strip
+		assert_equal("><", strip(">\n \t<"))
+		assert_equal("<mn>1</mn>", smml("1"))
+	end
+
+	def test_strip_mathml
+		src = "<math test='dummy'> <a> b </a> <c> d </c></math>"
+		assert_equal("<a>b</a><c>d</c>", strip_mathml(src))
+	end
+end

data/test/string_test.rb

@@ -0,0 +1,36 @@
+# Test for math_ml/util.rb
+#
+# Copyright (C) 2007, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+
+require "test/unit"
+require "math_ml/string"
+
+class TC_MathML_String < Test::Unit::TestCase
+	def setup
+		@mlp = MathML::LaTeX::Parser.new
+	end
+
+	def test_mathml_latex_parser
+		assert_kind_of(MathML::LaTeX::Parser, MathML::String.mathml_latex_parser)
+		mlp = MathML::LaTeX::Parser.new
+		MathML::String.mathml_latex_parser = mlp
+		assert_equal(mlp.object_id, MathML::String.mathml_latex_parser.object_id)
+		assert_raises(TypeError){MathML::String.mathml_latex_parser=String}
+		assert_equal(mlp.object_id, MathML::String.mathml_latex_parser.object_id)
+
+		MathML::String.mathml_latex_parser = nil
+		assert_kind_of(MathML::LaTeX::Parser, MathML::String.mathml_latex_parser)
+		assert_not_equal(mlp.object_id, MathML::String.mathml_latex_parser.object_id)
+	end
+
+	def test_to_mathml
+		assert_equal(@mlp.parse("").to_s, "".to_mathml.to_s)
+		assert_equal(@mlp.parse("", true).to_s, "".to_mathml(true).to_s)
+
+		MathML::String.mathml_latex_parser.macro.parse(<<'EOT')
+\newcommand{\test}{x}
+EOT
+		assert_equal(@mlp.parse("x").to_s, '\test'.to_mathml.to_s)
+	end
+end

data/test/util_test.rb

@@ -0,0 +1,694 @@
+# Test for math_ml/util.rb
+#
+# Copyright (C) 2006, KURODA Hiraku <hiraku@hinet.mydns.jp>
+# You can redistribute it and/or modify it under GPL2.
+
+require "test/unit"
+require "math_ml_test_util"
+require "math_ml"
+require "math_ml/util"
+
+class TC_MathML_Util < Test::Unit::TestCase
+	include MathML::Util
+
+	def test_escapeXML
+		assert_equal("&lt;&gt;&amp;&quot;&apos;", escapeXML("<>&\"'"))
+		assert_equal("\n", escapeXML("\n"))
+		assert_equal("<br />\n", escapeXML("\n", true))
+
+		assert_equal("&lt;&gt;&amp;&quot;&apos;", MathML::Util.escapeXML("<>&\"'"))
+		assert_equal("\n", MathML::Util.escapeXML("\n"))
+		assert_equal("<br />\n", MathML::Util.escapeXML("\n", true))
+	end
+
+	def test_collect_regexp
+		assert_equal(/#{/a/}|#{/b/}|#{/c/}/, collect_regexp([/a/, /b/, /c/]))
+		assert_equal(/#{/a/}|#{/b/}|#{/c/}/, collect_regexp([[/a/, /b/, /c/]]))
+		assert_equal(/(?!)/, collect_regexp([]))
+		assert_equal(/#{/a/}/, collect_regexp(/a/))
+
+		assert_equal(/#{/a/}|#{/b/}|#{/c/}/, MathML::Util.collect_regexp([/a/, /b/, /c/]))
+		assert_equal(/#{/a/}|#{/b/}|#{/c/}/, MathML::Util.collect_regexp([[/a/, /b/, /c/]]))
+		assert_equal(/(?!)/, MathML::Util.collect_regexp([]))
+		assert_equal(/#{/a/}/, MathML::Util.collect_regexp(/a/))
+
+		assert_equal(/#{/a/}|#{/b/}/, MathML::Util.collect_regexp([nil, /a/, "text", /b/]))
+
+		assert_equal(/#{/a/}|#{/b/}|#{/c/}/, MathML::Util.collect_regexp([nil, [/a/, [/b/, /c/]]]))
+	end
+
+	def test_invalid_re
+		assert_equal(/(?!)/, MathML::Util::INVALID_RE)
+	end
+end
+
+class TC_MathData < Test::Unit::TestCase
+	include MathML::Util
+
+	def test_update
+		m = MathData.new
+		m.math_list << "ml1"
+		m.msrc_list << "sl1"
+		m.dmath_list << "dml1"
+		m.dsrc_list << "dsl1"
+		m.escape_list << "el1"
+		m.esrc_list << "es1"
+		m.user_list << "ul1"
+		m.usrc_list << "usl1"
+		assert_equal(["ml1"], m.math_list)
+		assert_equal(["sl1"], m.msrc_list)
+		assert_equal(["dml1"], m.dmath_list)
+		assert_equal(["dsl1"], m.dsrc_list)
+		assert_equal(["el1"], m.escape_list)
+		assert_equal(["es1"], m.esrc_list)
+		assert_equal(["ul1"], m.user_list)
+		assert_equal(["usl1"], m.usrc_list)
+
+		m2 = MathData.new
+		m2.math_list << "ml2"
+		m2.msrc_list << "sl2"
+		m2.dmath_list << "dml2"
+		m2.dsrc_list << "dsl2"
+		m2.escape_list << "el2"
+		m2.esrc_list << "es2"
+		m2.user_list << "ul2"
+		m2.usrc_list << "usl2"
+
+		m.update(m2)
+
+		assert_equal(["ml1", "ml2"], m.math_list)
+		assert_equal(["sl1",  "sl2"], m.msrc_list)
+		assert_equal(["dml1", "dml2"], m.dmath_list)
+		assert_equal(["dsl1", "dsl2"], m.dsrc_list)
+		assert_equal(["el1", "el2"], m.escape_list)
+		assert_equal(["es1", "es2"], m.esrc_list)
+		assert_equal(["ul1", "ul2"], m.user_list)
+		assert_equal(["usl1", "usl2"], m.usrc_list)
+	end
+end
+
+class TC_SimpleLaTeX < Test::Unit::TestCase
+	include MathML::Util
+	include Util4TC_MathML
+
+	def strip_math(s)
+		strip(s)[/<math.*?>(.*)<\/math>/m, 1]
+	end
+
+	def sma(a) # Stripped Mathml Array
+		r = []
+		a.each do |i|
+			r << strip_math(i.to_s)
+		end
+		r
+	end
+
+	def assert_data(src,
+			expected_math, expected_src,
+			expected_dmath, expected_dsrc,
+			expected_escaped, expected_esrc,
+			expected_encoded, expected_decoded,
+			simple_latex = SimpleLaTeX)
+		encoded, data = simple_latex.encode(src)
+
+		data.math_list.each do |i|
+			assert_equal("inline", i.attributes[:display])
+		end
+		data.dmath_list.each do |i|
+			assert_equal("block", i.attributes[:display])
+		end
+
+		assert_equal(expected_math, sma(data.math_list))
+		assert_equal(expected_src, data.msrc_list)
+		assert_equal(expected_dmath, sma(data.dmath_list))
+		assert_equal(expected_dsrc, data.dsrc_list)
+		assert_equal(expected_escaped, data.escape_list)
+		assert_equal(expected_esrc, data.esrc_list)
+		assert_equal(expected_encoded, encoded)
+		assert_equal(expected_decoded, simple_latex.decode(encoded, data))
+	end
+
+	def test_math
+		assert_data("a\n$\nb\n$\nc\\(\nd\n\\)e",
+			["<mi>b</mi>", "<mi>d</mi>"],
+			["$\nb\n$", "\\(\nd\n\\)"],
+			[], [], [], [],
+			"a\n\001m0\001\nc\001m1\001e",
+			"a\n<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>b</mi></math>\nc<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>d</mi></math>e")
+
+		assert_data('$\\$$',
+			["<mo>$</mo>"],
+			['$\$$'], [], [], [], [], "\001m0\001",
+			"<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mo>$</mo></math>")
+	end
+
+	def test_dmath
+		assert_data("a\n$$\nb\n$$\nc\\[\nd\n\\]e",
+			[], [],
+			["<mi>b</mi>", "<mi>d</mi>"],
+			["$$\nb\n$$", "\\[\nd\n\\]"],
+			[], [],
+			"a\n\001d0\001\nc\001d1\001e",
+			"a\n<math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mi>b</mi></math>\nc<math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mi>d</mi></math>e")
+	end
+
+	def test_math_and_dmath
+		assert_data('a$b$c$$d$$e\(f\)g\[h\]i',
+			["<mi>b</mi>", "<mi>f</mi>"],
+			["$b$", '\(f\)'],
+			["<mi>d</mi>", "<mi>h</mi>"],
+			["$$d$$", '\[h\]'],
+			[], [],
+			"a\001m0\001c\001d0\001e\001m1\001g\001d1\001i",
+			"a<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>b</mi></math>c<math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mi>d</mi></math>e<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>f</mi></math>g<math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mi>h</mi></math>i")
+	end
+
+	def test_escapeing
+		assert_data('a\bc\d\e', [], [], [], [], ['b', 'd', 'e'], ['\b', '\d', '\e'], "a\001e0\001c\001e1\001\001e2\001", 'abcde')
+		assert_data('\$a$$b$$', [], [], ["<mi>b</mi>"], ["$$b$$"], [%[$]], ['\$'], "\001e0\001a\001d0\001",
+			"$a<math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mi>b</mi></math>")
+
+		assert_data("\\<\\\n", [], [], [], [], ["&lt;", "<br />\n"], ["\\<", "\\\n"], "\001e0\001\001e1\001", "&lt;<br />\n")
+	end
+
+	def test_through
+		s = SimpleLaTeX.new(:through_list=>[/\{\{.*\}\}/, /\(.*\)/])
+		assert_data("{{$a$}}($b$)", [], [], [], [], [], [], "{{$a$}}($b$)", "{{$a$}}($b$)", s)
+
+		s = SimpleLaTeX.new(:through_list=>/\{.*\}/)
+		assert_data("{$a$}", [], [], [], [], [], [], "{$a$}", "{$a$}", s)
+	end
+
+	def test_options_parser
+		ps = MathML::LaTeX::Parser.new
+		ps.macro.parse('\newcommand{\test}{t}')
+		s = SimpleLaTeX.new(:parser=>ps)
+		assert_data('$\test$', ["<mi>t</mi>"], ['$\test$'], [], [], [], [], "\001m0\001",
+			"<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>t</mi></math>", s)
+	end
+
+	def test_options_escape
+		s = SimpleLaTeX.new(:escape_list=>[/\/(.)/, /(\^.)/])
+		assert_data('\$a$', ["<mi>a</mi>"], ['$a$'], [], [], [], [], "\\\001m0\001",
+			"\\<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>a</mi></math>", s)
+		assert_data(%[/$a/$], [], [], [], [], [%[$], %[$]], [%[/$], %[/$]], "\001e0\001a\001e1\001", "$a$", s)
+		assert_data('^\(a^\)', [], [], [], [], ['^\\', '^\\'], ['^\\', '^\\'], "\001e0\001(a\001e1\001)", '^\(a^\)', s)
+
+		s = SimpleLaTeX.new(:escape_list=>/_(.)/)
+		assert_data("_$a$", [], [], [], [], ['$'], ["_$"], %[\001e0\001a$], '$a$', s)
+	end
+
+	def test_options_delimiter
+		s = SimpleLaTeX.new(:delimiter=>"\002\003")
+		assert_data("a$b$c", ["<mi>b</mi>"], ["$b$"], [], [], [], [], "a\002\003m0\002\003c",
+			"a<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>b</mi></math>c", s)
+
+		s = SimpleLaTeX.new(:delimiter=>"$")
+		assert_data("a$b$c", ["<mi>b</mi>"], ["$b$"], [], [], [], [], "a$m0$c",
+			"a<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>b</mi></math>c", s)
+	end
+
+	def test_options_math_env_list
+		s = SimpleLaTeX.new(:math_env_list=>/%(.*?)%/, :dmath_env_list=>/\[(.*?)\]/)
+		assert_data("a$b$c%d%e[f]", ["<mi>d</mi>"], ["%d%"], ["<mi>f</mi>"], ["[f]"], [], [],
+			"a$b$c\001m0\001e\001d0\001",
+			"a$b$c<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>d</mi></math>e<math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mi>f</mi></math>", s)
+
+		s = SimpleLaTeX.new(:math_env_list=>[/!(.*?)!/, /"(.*)"/], :dmath_env_list=>[/\#(.*)\#/, /&(.*)&/])
+		assert_data('a!b!c"d"e#f#g&h&i',
+			["<mi>b</mi>", "<mi>d</mi>"], ['!b!', '"d"'],
+			["<mi>f</mi>", "<mi>h</mi>"], ['#f#', '&h&'],
+			[], [],
+			"a\001m0\001c\001m1\001e\001d0\001g\001d1\001i",
+			"a<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>b</mi></math>c<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>d</mi></math>e<math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mi>f</mi></math>g<math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mi>h</mi></math>i", s)
+	end
+
+	def test_options_through_list
+		s = SimpleLaTeX.new(:through_list=>[/<%=.*?%>/m, /\(\(.*?\)\)/m])
+		assert_data("<%=$a$%>(($b$))", [], [], [], [], [], [], "<%=$a$%>(($b$))", "<%=$a$%>(($b$))", s)
+
+		s = SimpleLaTeX.new(:through_list=>/<%=.*?%>/)
+		assert_data("<%=$a$%>", [], [], [], [], [], [], "<%=$a$%>", "<%=$a$%>", s)
+	end
+
+	def test_empty_list
+		s = SimpleLaTeX.new(:through_list=>[])
+		assert_data("$a$", ["<mi>a</mi>"], [%[$a$]], [], [], [], [], "\001m0\001",
+			"<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>a</mi></math>", s)
+	end
+
+	def test_options_without_parse
+		s = SimpleLaTeX.new(:without_parse=>true)
+		encoded, data = s.encode("$a$ $$b$$")
+		assert_equal([], data.math_list)
+		assert_equal(["$a$"], data.msrc_list)
+		assert_equal([], data.dmath_list)
+		assert_equal(["$$b$$"], data.dsrc_list)
+		assert_equal("\001m0\001 \001d0\001", encoded)
+
+		s.parse(data)
+		assert_equal("inline", data.math_list[0].attributes[:display])
+		assert_equal("block", data.dmath_list[0].attributes[:display])
+		assert_equal(["<mi>a</mi>"], sma(data.math_list))
+		assert_equal(["<mi>b</mi>"], sma(data.dmath_list))
+		assert_equal("<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>a</mi></math> <math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mi>b</mi></math>", s.decode(encoded, data))
+	end
+
+	def test_set_encode_proc
+		s = SimpleLaTeX.new
+		s.set_encode_proc(/\{\{/) do |scanner|
+			if scanner.scan(/\{\{(.*?)\}\}/m)
+				"<%=#{scanner[1]}%>"
+			end
+		end
+		src = "{{$a$}}{{$$b$$}}{{"
+		assert_data(src, [], [], [], [], [], [], "\001u0\001\001u1\001{{", "<%=$a$%><%=$$b$$%>{{", s)
+		encoded, data = s.encode(src)
+		assert_equal(["<%=$a$%>", "<%=$$b$$%>"], data.user_list)
+		assert_equal(["{{$a$}}", "{{$$b$$}}"], data.usrc_list)
+
+		s.set_encode_proc(/\{\{/) do |scanner|
+		end
+		src = "{{a"
+		assert_data(src, [], [], [], [], [], [], "{{a", "{{a", s)
+		encoded, data = s.encode(src)
+		assert_equal([], data.user_list)
+		assert_equal([], data.usrc_list)
+	end
+
+	def test_encode_proc_with_arrayed_regexp
+		s = SimpleLaTeX.new
+		src = "{{a}}((b)){{(("
+		encoded, data = s.encode(src, /\{\{/, /\(\(/) do |scanner|
+			case
+			when scanner.scan(/\{\{.*?\}\}/)
+				"brace"
+			when scanner.scan(/\(\(.*?\)\)/)
+				"parenthesis"
+			end
+		end
+		assert_equal("\001u0\001\001u1\001{{((", encoded)
+		assert_equal("braceparenthesis{{((", s.decode(encoded, data))
+
+		s.set_encode_proc(/\{\{/, /\(\(/) do |scanner|
+			case
+			when scanner.scan(/\{\{.*?\}\}/)
+				"brace"
+			when scanner.scan(/\(\(.*?\)\)/)
+				"parenthesis"
+			end
+		end
+		encoded, data = s.encode(src)
+		assert_equal("\001u0\001\001u1\001{{((", encoded)
+		assert_equal("braceparenthesis{{((", s.decode(encoded, data))
+	end
+
+	def test_encode_with_proc
+		s = SimpleLaTeX.new
+		src = "{{$a$}}{{$$b$$}}{{"
+		encoded, data = s.encode(src, /\{\{/) do |scanner|
+			if scanner.scan(/\{\{(.*?)\}\}/m)
+				"<%=#{scanner[1]}%>"
+			end
+		end
+		assert_equal([], data.math_list)
+		assert_equal([], data.dmath_list)
+		assert_equal([], data.escape_list)
+		assert_equal("\001u0\001\001u1\001{{", encoded)
+		assert_equal("<%=$a$%><%=$$b$$%>{{", s.decode(encoded, data))
+	end
+
+	def test_encode_with_proc_with_encode_proc_set
+		s = SimpleLaTeX.new
+		src = "{{$a$}}{{$$b$$}}{{"
+		s.set_encode_proc(/\{\{/) do |scanner|
+			if scanner.scan(/\{\{(.*?)\}\}/m)
+				"<%=#{scanner[1]}%>"
+			end
+		end
+		encoded, data = s.encode(src, /\{\{/) do |scanner|
+			if scanner.scan(/\{\{(.*?)\}\}/m)
+				"<$=#{scanner[1]}$>"
+			end
+		end
+		assert_equal([], data.math_list)
+		assert_equal([], data.dmath_list)
+		assert_equal([], data.escape_list)
+		assert_equal("\001u0\001\001u1\001{{", encoded)
+		assert_equal("<$=$a$$><$=$$b$$$>{{", s.decode(encoded, data))
+	end
+
+	def test_unencode
+		src = "$\na\n$\n$$\nb\n$$"
+		s = SimpleLaTeX.new
+		encoded, data = s.encode(src)
+		assert_equal("$<br />\na<br />\n$\n$$<br />\nb<br />\n$$", s.unencode(encoded, data))
+
+		s = SimpleLaTeX.new(:delimiter=>"$")
+		e, d = s.encode("$a$")
+		assert_equal("$a$", s.unencode(e, d))
+	end
+
+	def test_set_rescue_proc
+		src = '$a\test$ $$b\dummy$$'
+		s = SimpleLaTeX.new
+		encoded, data = s.encode(src)
+		assert_equal("<br />\nUndefined command.<br />\n<code>a<strong>\\test</strong></code><br />", data.math_list[0])
+		assert_equal("<br />\nUndefined command.<br />\n<code>b<strong>\\dummy</strong></code><br />", data.dmath_list[0])
+
+		s.set_rescue_proc do |e|
+			e
+		end
+		encoded, data = s.encode(src)
+		assert_kind_of(MathML::LaTeX::ParseError, data.math_list[0])
+		assert_equal("a", data.math_list[0].done)
+		assert_kind_of(MathML::LaTeX::ParseError, data.dmath_list[0])
+		assert_equal("b", data.dmath_list[0].done)
+	end
+
+	def test_decode_with_proc
+		s = SimpleLaTeX.new
+		encoded, data = s.encode('$a$$b$$$c$$$$d$$\e\\\\')
+		r = s.decode(encoded, data) do |item, opt|
+			case opt[:type]
+			when :dmath
+				assert_equal("block", item.attributes[:display])
+				i = strip_math(item.to_s)
+			when :math
+				assert_equal("inline", item.attributes[:display])
+				i = strip_math(item.to_s)
+			else
+				i = item
+			end
+			r = "t#{opt[:type]}i#{opt[:index]}s#{opt[:src]}#{i}"
+		end
+		assert_equal("tmathi0s$a$<mi>a</mi>tmathi1s$b$<mi>b</mi>tdmathi0s$$c$$<mi>c</mi>tdmathi1s$$d$$<mi>d</mi>tescapei0s\\eetescapei1s\\\\\\", r)
+
+		r = s.decode(encoded, data) do |item, opt|
+			nil
+		end
+		assert_equal(s.decode(encoded, data), r)
+
+		s.set_encode_proc(/\{\{/) do |scanner|
+			"<%=#{scanner[1]}%>" if scanner.scan(/\{\{(.*?)\}\}/m)
+		end
+		encoded, data = s.encode("{{a}}{{")
+		r = s.decode(encoded, data) do |item, opt|
+			assert_equal("<%=a%>", item)
+			assert_equal(:user, opt[:type])
+			assert_equal(0, opt[:index])
+			assert_equal("{{a}}", opt[:src])
+			nil
+		end
+		assert_equal("<%=a%>{{", r)
+
+		s.set_decode_proc do |item, opt|
+			"dummy"
+		end
+		assert_equal("dummy{{", s.decode(encoded, data))
+		r = s.decode(encoded, data) do |item, opt|
+			nil
+		end
+		assert_equal("<%=a%>{{", r)
+	end
+
+	def test_set_decode_proc
+		s = SimpleLaTeX.new
+		src = '$a$$b$$$c$$$$d$$\e\\\\'
+		encoded, data = s.encode(src)
+		original_decoded = s.decode(encoded, data)
+		s.set_decode_proc do |item, opt|
+			case opt[:type]
+			when :dmath
+				assert_equal("block", item.attributes[:display])
+				i = strip_math(item.to_s)
+			when :math
+				assert_equal("inline", item.attributes[:display])
+				i = strip_math(item.to_s)
+			else
+				i = item
+			end
+			r = "t#{opt[:type]}i#{opt[:index]}s#{opt[:src]}#{i}"
+		end
+		encoded, data = s.encode(src)
+		r = s.decode(encoded, data)
+		assert_equal("tmathi0s$a$<mi>a</mi>tmathi1s$b$<mi>b</mi>tdmathi0s$$c$$<mi>c</mi>tdmathi1s$$d$$<mi>d</mi>tescapei0s\\eetescapei1s\\\\\\", r)
+
+		s.reset_decode_proc
+		assert_equal(original_decoded, s.decode(encoded, data))
+	end
+
+	def test_unencode_with_proc
+		s = SimpleLaTeX.new
+		src = '$a$$b$$$c$$$$d$$\e\\\\'
+		encoded, data = s.encode(src)
+		r = s.unencode(encoded, data) do |item, opt|
+			r = "t#{opt[:type]}i#{opt[:index]}#{item.to_s}"
+		end
+		assert_equal("tmathi0$a$tmathi1$b$tdmathi0$$c$$tdmathi1$$d$$tescapei0\\etescapei1\\\\", r)
+
+		r = s.unencode(encoded, data) do |item, opt|
+			nil
+		end
+		assert_equal(s.unencode(encoded, data), r)
+
+		s.set_encode_proc(/\{\{/) do |scanner|
+			"<%=#{scanner[1]}%>" if scanner.scan(/\{\{(.*?)\}\}/m)
+		end
+		encoded, data = s.encode("{{a}}{{")
+		r = s.unencode(encoded, data) do |item, opt|
+			assert_equal("{{a}}", item)
+			assert_equal(:user, opt[:type])
+			assert_equal(0, opt[:index])
+			nil
+		end
+		assert_equal("{{a}}{{", r)
+	end
+
+	def test_unencode_proc
+		s = SimpleLaTeX.new
+		src = '$a$$b$$$c$$$$d$$\e\\\\'
+		encoded, data = s.encode(src)
+		original_unencoded = s.unencode(encoded, data)
+
+		s.set_unencode_proc do |item, opt|
+			r = "t#{opt[:type]}i#{opt[:index]}#{item.to_s}"
+		end
+		r = s.unencode(encoded, data)
+		assert_equal("tmathi0$a$tmathi1$b$tdmathi0$$c$$tdmathi1$$d$$tescapei0\\etescapei1\\\\", r)
+
+		s.set_unencode_proc do |item, opt|
+			nil
+		end
+		assert_equal(original_unencoded, s.unencode(encoded, data))
+
+		s.set_encode_proc(/\{\{/) do |scanner|
+			"<%=#{scanner[1]}%>" if scanner.scan(/\{\{(.*?)\}\}/m)
+		end
+		encoded, data = s.encode("{{a}}{{")
+		s.set_unencode_proc do |item, opt|
+			assert_equal("{{a}}", item)
+			assert_equal(:user, opt[:type])
+			assert_equal(0, opt[:index])
+			nil
+		end
+		r = s.unencode(encoded, data)
+		assert_equal("{{a}}{{", r)
+	end
+
+	def test_reset_unencode_proc
+		s = SimpleLaTeX.new
+		s.set_unencode_proc do |item, opt|
+			"dummy"
+		end
+		encoded, data = s.encode("$a$ $$b$$")
+		assert_equal("dummy dummy", s.unencode(encoded, data))
+
+		s.reset_unencode_proc
+		assert_equal("$a$ $$b$$", s.unencode(encoded, data))
+	end
+
+	def test_unencode_escaping
+		s = SimpleLaTeX.new
+		src = %[$<>&'"\n$ $$<>&"'\n$$]
+		encoded, data = s.encode(src)
+		assert_equal("$&lt;&gt;&amp;&apos;&quot;<br />\n$ $$&lt;&gt;&amp;&quot;&apos;<br />\n$$", s.unencode(encoded, data))
+		assert_equal(src, s.unencode(encoded, data, true), "without escaping")
+	end
+
+	def test_decode_without_parsed
+		s = SimpleLaTeX.new
+		src = '$a$$$b$$\a'
+		encoded, data = s.encode(src)
+		assert_equal("$a$$$b$$a", s.decode(encoded, data, true))
+		s.decode(encoded, data, true) do |item, opt|
+			case opt[:type]
+			when :math
+				assert_equal("$a$", item)
+			when :dmath
+				assert_equal("$$b$$", item)
+			when :escape
+				assert_equal("a", item)
+			end
+		end
+
+		encoded, data = s.encode("$<\n$ $$<\n$$")
+		assert_equal("$&lt;<br />\n$ $$&lt;<br />\n$$", s.decode(encoded, data, true))
+	end
+
+	def test_decode_partial
+		s = SimpleLaTeX.new
+		encoded, data = s.encode("$a$$b$")
+		assert_equal("<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>a</mi></math><math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>b</mi></math>", s.decode_partial(:math, encoded, data))
+
+		s.set_encode_proc(/\\</) do |scanner|
+			if scanner.scan(/\\<(.)(.*?)\1>/)
+				scanner[2]
+			end
+		end
+		src='$a$$$b$$\c\<.$d$.>'
+		encoded, data = s.encode(src)
+		assert_equal("<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>a</mi></math>\001d0\001\001e0\001\001u0\001", s.decode_partial(:math, encoded, data))
+		assert_equal("\001m0\001<math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mi>b</mi></math>\001e0\001\001u0\001", s.decode_partial(:dmath, encoded, data))
+		assert_equal("\001m0\001\001d0\001c\001u0\001", s.decode_partial(:escape, encoded, data))
+		assert_equal("\001m0\001\001d0\001\001e0\001$d$", s.decode_partial(:user, encoded, data))
+
+		r = s.decode_partial(:math, encoded, data) do |item, opt|
+			assert_equal(:math, opt[:type])
+			assert_equal("$a$", opt[:src])
+			assert_equal("<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>a</mi></math>", item.to_s)
+			item
+		end
+		assert_equal("<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>a</mi></math>\001d0\001\001e0\001\001u0\001", r)
+
+		r = s.decode_partial(:dmath, encoded, data) do |item, opt|
+			assert_equal(:dmath, opt[:type])
+			assert_equal("$$b$$", opt[:src])
+			assert_equal("<math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mi>b</mi></math>", item.to_s)
+			item
+		end
+		assert_equal("\001m0\001<math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mi>b</mi></math>\001e0\001\001u0\001", r)
+
+		r = s.decode_partial(:escape, encoded, data) do |item, opt|
+			assert_equal(:escape, opt[:type])
+			assert_equal("\\c", opt[:src])
+			assert_equal("c", item)
+			item
+		end
+		assert_equal("\001m0\001\001d0\001c\001u0\001", r)
+
+		r = s.decode_partial(:user, encoded, data) do |item, opt|
+			assert_equal(:user, opt[:type])
+			assert_equal("\\<.$d$.>", opt[:src])
+			assert_equal("$d$", item)
+			item
+		end
+		assert_equal("\001m0\001\001d0\001\001e0\001$d$", r)
+
+		s = SimpleLaTeX.new
+		encoded, data = s.encode("\\a")
+		assert_equal("a", s.decode_partial(:escape, encoded, data))
+		r = s.decode_partial(:escape, encoded, data) do |item, opt|
+		end
+		assert_equal("\001e0\001", r)
+
+		s = SimpleLaTeX.new(:delimiter=>"$")
+		encoded, data = s.encode("$a$")
+		assert_match(/^<math.*<\/math>/m, s.decode_partial(:math, encoded, data))
+	end
+
+	def test_regexp_order
+		s = SimpleLaTeX.new
+		s.set_encode_proc(/\$/) do |sc|
+			if sc.scan(/\$(.*)\z/)
+				sc[1]+"is rest"
+			end
+		end
+
+		encoded, data = s.encode("$a$$b")
+		assert_equal("\001m0\001\001u0\001", encoded)
+	end
+
+	def test_eqnarray
+		s = SimpleLaTeX.new
+		src = <<'EOT'
+test
+\begin
+{eqnarray}
+a&=&b\\
+c&=&d
+\end
+{eqnarray}
+end
+EOT
+		encoded, data = s.encode(src, MathML::Util::EQNARRAY_RE) do |scanner|
+			if scanner.scan(MathML::Util::EQNARRAY_RE)
+				s.parse_eqnarray(scanner[1])
+			end
+		end
+		assert_equal("test\n\001u0\001\nend\n", encoded)
+		assert_equal("test\n<math display='block' xmlns='http://www.w3.org/1998/Math/MathML'><mtable><mtr><mtd><mi>a</mi></mtd><mtd><mo>=</mo></mtd><mtd><mi>b</mi></mtd></mtr><mtr><mtd><mi>c</mi></mtd><mtd><mo>=</mo></mtd><mtd><mi>d</mi></mtd></mtr></mtable></math>\nend\n", s.decode(encoded, data).gsub(/>\s*</, "><"))
+
+		encoded, data = s.encode('\begin{eqnarray}a\end{eqnarray}', MathML::Util::EQNARRAY_RE) do |scanner|
+			s.parse_eqnarray(scanner[1]) if scanner.scan(MathML::Util::EQNARRAY_RE)
+		end
+		assert_equal("<br />\nNeed more column.<br />\n<code>\\begin{eqnarray}a<strong>\\end{eqnarray}</strong></code><br />", s.decode(encoded, data))
+	end
+
+	def test_single_command
+		s = SimpleLaTeX.new
+		encoded, data = s.encode(%q[\alpha\|\<\>\&\"\'\test], MathML::Util::SINGLE_COMMAND_RE) do |scanner|
+			if scanner.scan(MathML::Util::SINGLE_COMMAND_RE)
+				s.parse_single_command(scanner.matched)
+			end
+		end
+		assert_equal("\001u0\001\001e0\001\001e1\001\001e2\001\001e3\001\001e4\001\001e5\001\001u1\001", encoded)
+		assert_equal("<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>&alpha;</mi></math>|&lt;&gt;&amp;&quot;&apos;test", s.decode(encoded, data))
+		encoded, data = s.encode('\alpha test', MathML::Util::SINGLE_COMMAND_RE) do |scanner|
+			if scanner.scan(MathML::Util::SINGLE_COMMAND_RE)
+				s.parse_single_command(scanner.matched)
+			end
+		end
+		assert_equal("\001u0\001test", encoded)
+		assert_equal("<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>&alpha;</mi></math>test", s.decode(encoded, data))
+
+		encoded, data = s.encode('\alpha  test', MathML::Util::SINGLE_COMMAND_RE) do |scanner|
+			if scanner.scan(MathML::Util::SINGLE_COMMAND_RE)
+				s.parse_single_command(scanner.matched)
+			end
+		end
+		assert_equal("\001u0\001 test", encoded)
+		assert_equal("<math display='inline' xmlns='http://www.w3.org/1998/Math/MathML'><mi>&alpha;</mi></math> test", s.decode(encoded, data))
+
+		encoded, data = s.encode("\\alpha\ntest", MathML::Util::SINGLE_COMMAND_RE) do |scanner|
+			if scanner.scan(MathML::Util::SINGLE_COMMAND_RE)
+				s.parse_single_command(scanner.matched)
+			end
+		end
+		assert_equal("\001u0\001\ntest", encoded)
+	end
+
+	def test_encode_append
+		s = SimpleLaTeX.new
+		encoded, data = s.encode('$a$')
+		encoded, data = s.encode('$b$', data)
+		assert_equal("\001m1\001", encoded)
+		assert_equal(["$a$", '$b$'], data.msrc_list)
+		assert_equal(2, data.math_list.size)
+		assert_equal("<mi>a</mi>", strip_mathml(data.math_list[0].to_s))
+		assert_equal("<mi>b</mi>", strip_mathml(data.math_list[1].to_s))
+
+		encoded, data = s.encode('a', data, /a/) do |sc|
+			sc.scan(/a/)
+		end
+		assert_equal("\001u0\001", encoded)
+		assert_equal(["$a$", '$b$'], data.msrc_list)
+		assert_equal(["a"], data.usrc_list)
+
+		encoded, data = s.encode('a', nil, /a/) do |s|
+			s.scan(/a/)
+		end
+		assert_equal("\001u0\001", encoded)
+		assert_equal(["a"], data.usrc_list)
+	end
+end