webgen 0.5.10 → 0.5.11

data/test/test_contentprocessor_blocks.rb

@@ -15,9 +15,11 @@ class TestContentProcessorBlocks < Test::Unit::TestCase
     root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
     node = Webgen::Node.new(root, 'test', 'test')
     node.node_info[:page] = Webgen::Page.from_data("--- name:content\ndata\n--- name:other\nother")
+    dnode = Webgen::Node.new(root, 'dtest', 'dtest')
+    dnode.node_info[:page] = Webgen::Page.from_data("--- name:content pipeline:erb\n<%= context.dest_node.alcn %>")
     template = Webgen::Node.new(root, 'template', 'template')
     template.node_info[:page] = Webgen::Page.from_data("--- name:content pipeline:blocks\nbefore<webgen:block name='content' />after")
-    processors = { 'blocks' => obj }
+    processors = { 'blocks' => obj, 'erb' => Webgen::ContentProcessor::Erb.new }
 
     context = Webgen::Context.new(:chain => [node], :processors => processors)
     context.content = '<webgen:block name="content" /><webgen:block name="content" chain="template;test" />'
@@ -42,6 +44,19 @@ class TestContentProcessorBlocks < Test::Unit::TestCase
     assert_equal('beforedataafter', context.content)
     assert_equal(Set.new([template.alcn, node.alcn]), node.node_info[:used_nodes])
 
+    # Test correctly set dest_node
+    context[:chain] = [node]
+    context.content = '<webgen:block name="content" chain="dtest" />'
+    obj.call(context)
+    assert_equal('/test', context.content)
+
+    context.content = '<webgen:block name="content" chain="dtest" />'
+    assert_equal('/test', obj.render_block(context, :chain => [dnode], :name => 'content'))
+
+
+    # Test options "node" and "notfound"
+    context[:chain] = [node, template, node]
+
     context.content = 'bef<webgen:block name="other" chain="template;test" notfound="ignore" />aft'
     obj.call(context)
     assert_equal('befaft', context.content)

data/test/test_contentprocessor_erb.rb

@@ -13,7 +13,7 @@ class TestContentProcessorErb < Test::Unit::TestCase
     obj = Webgen::ContentProcessor::Erb.new
     root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
     node = Webgen::Node.new(root, 'test', 'test')
-    content = "<%= context[:doit] %>6\n<%= context.ref_node.alcn %>\n<%= context.node.alcn %>\n<%= context.dest_node.alcn %><% website %>"
+    content = "<%= context[:doit] %>6\n<%= context.ref_node.alcn %>\n<%= context.node.alcn %>\n<%= context.dest_node.alcn %><% context.website %>"
     context = Webgen::Context.new(:content => content, :doit => 'hallo',
                                                     :chain => [node])
     obj.call(context)

data/test/test_contentprocessor_fragments.rb

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 
 require 'test/unit'
-require 'test/helper'
+require 'helper'
 require 'webgen/page'
 require 'webgen/tree'
 require 'webgen/contentprocessor'

data/test/test_contentprocessor_haml.rb

@@ -19,11 +19,11 @@ class TestContentProcessorHaml < Test::Unit::TestCase
     obj.call(context)
     assert_equal("<div id='content'>\n  <h1>Hallo</h1>\n  /test/test/test/test\n</div>\n", context.content)
 
-    context.content = "#cont\n    %unknown"
+    context.content = "#cont\n    % = + unknown"
     assert_error_on_line(Webgen::RenderError, 2) { obj.call(context) }
 
     context.content = "#cont\n  = unknown"
-    assert_raise(Webgen::RenderError) { obj.call(context) }
+    assert_error_on_line(Webgen::RenderError, 2) { obj.call(context) }
 
     def obj.require(lib); raise LoadError; end
     assert_raise(Webgen::LoadError) { obj.call(context) }

data/test/test_contentprocessor_head.rb

@@ -10,16 +10,23 @@ class TestContentProcessorHead < Test::Unit::TestCase
 
   include Test::WebsiteHelper
 
-  def test_call
-    obj = Webgen::ContentProcessor::Head.new
-    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
-    node = Webgen::Node.new(root, 'test', 'test', {'meta' => {'other' => 'me'}})
+  def setup
+    super
+    @obj = Webgen::ContentProcessor::Head.new
+    @root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    @node = Webgen::Node.new(@root, 'test.en', 'test', {'lang' => 'en'})
+  end
 
-    context = Webgen::Context.new(:chain => [node])
+  def test_meta_information
+    context = Webgen::Context.new(:chain => [@node])
     context.content = '</head>'
-    obj.call(context)
+    @node['meta'] = {'other' => 'me'}
+    @obj.call(context)
     assert_equal("\n<meta name=\"other\" content=\"me\" /></head>", context.content)
+  end
 
+  def test_persistent_information
+    context = Webgen::Context.new(:chain => [@node])
     context.content = '</head>'
     context.clone.persistent[:cp_head] = {
       :js_file => ['hallo.js', 'hallo2.js', 'hallo.js'],
@@ -28,8 +35,7 @@ class TestContentProcessorHead < Test::Unit::TestCase
       :css_inline => ["somestyle", "anotherstyle"],
       :meta => {:lucky => 'me<"'}
     }
-    node['meta'].clear
-    obj.call(context)
+    @obj.call(context)
     assert_equal("\n<script type=\"text/javascript\" src=\"hallo.js\"></script>" +
                  "\n<script type=\"text/javascript\" src=\"hallo2.js\"></script>" +
                  "\n<script type=\"text/javascript\">\nsomescript\n</script>" +
@@ -41,4 +47,44 @@ class TestContentProcessorHead < Test::Unit::TestCase
                  "\n<meta name=\"lucky\" content=\"me&lt;&quot;\" /></head>", context.content)
   end
 
+  def test_links_to_other_lang_nodes
+    context = Webgen::Context.new(:chain => [@node])
+    context.content = '</head>'
+    @obj.call(context)
+    assert_equal("</head>", context.content)
+
+    de_node = Webgen::Node.new(@root, 'test.de', 'test', {'lang' => 'de'})
+    @obj.call(context)
+    assert_equal("\n<link type=\"text/html\" rel=\"alternate\" hreflang=\"de\" href=\"test.de\" /></head>", context.content)
+
+    context.content = '</head>'
+    de_node['title'] = 'Deutscher Titel'
+    @obj.call(context)
+    assert_equal("\n<link type=\"text/html\" rel=\"alternate\" hreflang=\"de\" href=\"test.de\" " +
+                 "lang=\"de\" title=\"Deutscher Titel\" /></head>", context.content)
+  end
+
+  def test_javascript_and_css_links
+    context = Webgen::Context.new(:chain => [@node])
+    context.content = '</head>'
+    @node['link'] = {'javascript' => 'http://example.org', 'css' => ['http://example.org', 'test', 'unknown']}
+    @obj.call(context)
+    assert_equal("\n<script type=\"text/javascript\" src=\"http://example.org\"></script>" +
+                 "\n<link rel=\"stylesheet\" href=\"http://example.org\" type=\"text/css\" />" +
+                 "\n<link rel=\"stylesheet\" href=\"test.en\" type=\"text/css\" /></head>", context.content)
+  end
+
+  def test_generic_links
+    context = Webgen::Context.new(:chain => [@node])
+    context.content = '</head>'
+    @node['link'] = {'next' => 'test', 'start' => {'type' => 'text/xhtml', 'href' => 'http://example.org'},
+      'alternate' => ['test', {'type' => 'text/html', 'href' => 'test'}, {'href' => 'unknown'}, {'type' => 'text/html'}]
+    }
+    @obj.call(context)
+    assert_equal("\n<link href=\"test.en\" rel=\"alternate\" />" +
+                 "\n<link href=\"test.en\" rel=\"alternate\" type=\"text/html\" />" +
+                 "\n<link href=\"test.en\" rel=\"next\" type=\"text/html\" />" +
+                 "\n<link href=\"http://example.org\" rel=\"start\" type=\"text/xhtml\" /></head>", context.content)
+  end
+
 end

data/test/test_contentprocessor_kramdown.rb

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/node'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorKramdown < Test::Unit::TestCase
+
+  include Test::WebsiteHelper
+
+  def test_call
+    obj = Webgen::ContentProcessor::Kramdown.new
+    node = Webgen::Node.new(Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/'), 'test', 'test')
+    hello = Webgen::Node.new(node.tree.root, 'hello.en.html', 'hello.html')
+
+    # test normal invocation
+    context = Webgen::Context.new(:content => '# header', :chain => [node])
+    assert_equal("<h1 id=\"header\">header</h1>\n", obj.call(context).content)
+
+    # test automatic handling of links
+    @website.config['contentprocessor.kramdown.handle_links'] = true
+    context.content = 'Link [test](hello.html)'
+    assert_equal("<p>Link <a href=\"hello.en.html\">test</a></p>\n", obj.call(context).content)
+    context.content = 'Link ![test](hello.html)'
+    assert_equal("<p>Link <img alt=\"test\" src=\"hello.en.html\" /></p>\n", obj.call(context).content)
+
+    @website.config['contentprocessor.kramdown.handle_links'] = false
+    context.content = 'Link [test](hello.html)'
+    assert_equal("<p>Link <a href=\"hello.html\">test</a></p>\n", obj.call(context).content)
+    context.content = 'Link ![test](hello.html)'
+    assert_equal("<p>Link <img alt=\"test\" src=\"hello.html\" /></p>\n", obj.call(context).content)
+
+    # test warning messages
+    output = StringIO.new('')
+    @website.logger = ::Logger.new(output)
+    @website.logger.level = Logger::WARN
+
+    context.content = '{::unknownextension::}'
+    obj.call(context)
+    assert_equal("", context.content)
+    output.rewind; assert_match(/No extension named 'unknownextension' found/, output.read)
+
+    # test raised error when library not found
+    def obj.require(lib); raise LoadError; end
+    assert_raise(Webgen::LoadError) { obj.call(context) }
+  end
+
+end

data/test/test_contentprocessor_less.rb

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+
+require 'test/unit'
+require 'helper'
+require 'webgen/tree'
+require 'webgen/contentprocessor'
+
+class TestContentProcessorLess < Test::Unit::TestCase
+
+  include Test::WebgenAssertions
+
+  def test_call
+    obj = Webgen::ContentProcessor::Less.new
+    root = Webgen::Node.new(Webgen::Tree.new.dummy_root, '/', '/')
+    node = Webgen::Node.new(root, 'test', 'test')
+    context = Webgen::Context.new(:content => "div {width: 1 + 1}",
+                                  :chain => [node])
+    obj.call(context)
+    assert_equal("div { width: 2; }\n", context.content)
+
+    context.content = ".class {color: yellow}\ndiv {width: 1 + }"
+    assert_error_on_line(Webgen::RenderError, 2) { obj.call(context) }
+
+    context.content = "div { width: 2em + 1px; }"
+    assert_raise(Webgen::RenderError) { obj.call(context) }
+
+    context.content = "div {width: @hallo + 1}"
+    assert_raise(Webgen::RenderError) { obj.call(context) }
+
+    context.content = "div {width: 1px; .mixin;}"
+    assert_raise(Webgen::RenderError) { obj.call(context) }
+
+    context.content = "@import \"hallo\";"
+    assert_raise(Webgen::RenderError) { obj.call(context) }
+
+    def obj.require(lib); raise LoadError; end
+    assert_raise(Webgen::LoadError) { obj.call(context) }
+  end
+
+end

data/test/test_contentprocessor_tags.rb

@@ -78,6 +78,14 @@ class TestContentProcessorTags < Test::Unit::TestCase
     check_returned_tags('before{test::}body\\{test}\\\\{test}after', [['test', '', 'body{test}\\']], "beforetest1after")
     check_returned_tags('before\\{test::}body{test}', [['test', '', 'body']], "before{test::}body{test}")
     check_returned_tags('before\\\\{test:: asdf}body{test}after', [['test', ' asdf', 'body']], "before\\test1after")
+
+    check_returned_tags('sdfsüdf{test: }', [['test', ' ', '']], "sdfsüdftest1")
+    check_returned_tags('sdfsüüdf{test: asdf}', [['test', ' asdf', '']], "sdfsüüdftest1")
+    check_returned_tags('sdfsüüdf{test: asüdf}a', [['test', ' asüdf', '']], "sdfsüüdftest1a")
+    check_returned_tags('sdfsüüdf\\{test: asdf}ab', [], "sdfsüüdf{test: asdf}ab")
+    check_returned_tags('sdfsüüdf\\\\{test: asdf}ab', [['test', ' asdf', '']], "sdfsüüdf\\test1ab")
+    check_returned_tags('sdfsüüdf\\\\\\{test: asdf}ab', [], "sdfsüüdf\\{test: asdf}ab")
+    check_returned_tags('sdfsüüdf{test:: asdf}abü{test}ab', [['test', ' asdf', 'abü']], "sdfsüüdftest1ab")
   end
 
   def test_processor_for_tag

data/test/test_node.rb

@@ -17,19 +17,21 @@ class TestNode < Test::Unit::TestCase
   def create_default_nodes
     {
       :root => node = Webgen::Node.new(@tree.dummy_root, '/', '/'),
-      :somename_en => child_en = Webgen::Node.new(node, '/somename.en.html', 'somename.page', {'lang' => 'en', 'title' => 'somename'}),
-      :somename_de => child_de = Webgen::Node.new(node, '/somename.de.html', 'somename.page', {'lang' => 'de'}),
-      :other => Webgen::Node.new(node, '/other.html', 'other.page', {}),
-      :other_en => Webgen::Node.new(node, '/other1.html', 'other.page', {'lang' => 'en'}),
+      :somename_en => child_en = Webgen::Node.new(node, '/somename.en.html', 'somename.html', {'lang' => 'en', 'title' => 'somename en'}),
+      :somename_de => child_de = Webgen::Node.new(node, '/somename.de.html', 'somename.html', {'lang' => 'de', 'title' => 'somename de', 'sort_test' => 1}),
+      :other => Webgen::Node.new(node, '/other.html', 'other.html', {'title' => 'other', 'sort_test' => 5}),
+      :other_en => Webgen::Node.new(node, '/other1.html', 'other.html', {'lang' => 'en', 'title' => 'other en', 'sort_test' => 4}),
       :somename_en_frag => frag_en = Webgen::Node.new(child_en, '/somename.en.html#frag', '#othertest', {'title' => 'frag'}),
-      :somename_de_frag => Webgen::Node.new(child_de, '/somename.de.html#frag', '#othertest'),
-      :somename_en_fragnest => Webgen::Node.new(frag_en, '/somename.en.html#fragnest/', '#nestedpath'),
-      :dir => dir = Webgen::Node.new(node, '/dir/', 'dir/'),
-      :dir_file => dir_file = Webgen::Node.new(dir, '/dir/file.html', 'file.html'),
-      :dir_file_frag => Webgen::Node.new(dir_file, '/dir/file.html#frag', '#frag'),
+      :somename_de_frag => Webgen::Node.new(child_de, '/somename.de.html#frag', '#othertest', {'title' => 'frag'}),
+      :somename_en_fragnest => Webgen::Node.new(frag_en, '/somename.en.html#fragnest/', '#nestedpath', {'title' => 'fragnest'}),
+      :dir => dir = Webgen::Node.new(node, '/dir/', 'dir/', {'title' => 'dir'}),
+      :dir_file => dir_file = Webgen::Node.new(dir, '/dir/file.html', 'file.html', {'title' => 'file'}),
+      :dir_file_frag => Webgen::Node.new(dir_file, '/dir/file.html#frag', '#frag', {'title' => 'frag'}),
       :dir2 => dir2 = Webgen::Node.new(node, '/dir2/', 'dir2/', {'index_path' => 'index.html', 'title' => 'dir2'}),
-      :dir2_index_en => Webgen::Node.new(dir2, '/dir2/index.html', 'index.html', {'lang' => 'en', 'routed_title' => 'routed', 'title' => 'index'}),
-      :dir2_index_de => Webgen::Node.new(dir2, '/dir2/index.de.html', 'index.html', {'lang' => 'de', 'routed_title' => 'routed_de', 'title' => 'index'}),
+      :dir2_index_en => Webgen::Node.new(dir2, '/dir2/index.html', 'index.html',
+                                         {'lang' => 'en', 'routed_title' => 'routed', 'title' => 'index en', 'sort_info' => 1}),
+      :dir2_index_de => Webgen::Node.new(dir2, '/dir2/index.de.html', 'index.html',
+                                         {'lang' => 'de', 'routed_title' => 'routed_de', 'title' => 'index de', 'sort_info' => 2}),
     }
   end
 
@@ -52,9 +54,9 @@ class TestNode < Test::Unit::TestCase
     node = Webgen::Node.new(@tree.dummy_root, '/', '/', {'lang' => 'de', :test => :value})
     check_proc.call(node, @tree.dummy_root, '/', '/', '/', '/', nil, {:test => :value})
 
-    child = Webgen::Node.new(node, 'somename.html', 'somename.page',  {'lang' => 'de'})
-    check_proc.call(child, node, 'somename.html', 'somename.page', 'somename.de.page',
-                    '/somename.de.page', 'de', {})
+    child = Webgen::Node.new(node, 'somename.html', 'somename.html',  {'lang' => 'de'})
+    check_proc.call(child, node, 'somename.html', 'somename.html', 'somename.de.html',
+                    '/somename.de.html', 'de', {})
 
     ['http://webgen.rubyforge.org', 'c:\\test'].each_with_index do |abspath, index|
       cn = 'test' + index.to_s + '.html'
@@ -63,8 +65,8 @@ class TestNode < Test::Unit::TestCase
     end
 
     child.reinit('somename.en.html', {'lang' => 'de', 'title' => 'test'})
-    check_proc.call(child, node, 'somename.en.html', 'somename.page', 'somename.de.page',
-                    '/somename.de.page', 'de', {'title' => 'test'})
+    check_proc.call(child, node, 'somename.en.html', 'somename.html', 'somename.de.html',
+                    '/somename.de.html', 'de', {'title' => 'test'})
   end
 
   def test_type_checkers
@@ -126,33 +128,33 @@ class TestNode < Test::Unit::TestCase
     nodes = create_default_nodes
 
     [nodes[:root], nodes[:somename_de], nodes[:somename_en], nodes[:other]].each do |n|
-      assert_equal(nil, n.resolve('somename.page', nil))
-      assert_equal(nodes[:somename_en], n.resolve('somename.page', 'en'))
-      assert_equal(nodes[:somename_de], n.resolve('somename.page', 'de'))
-      assert_equal(nil, n.resolve('somename.page', 'fr'))
-      assert_equal(nodes[:somename_en], n.resolve('somename.en.page', nil))
-      assert_equal(nodes[:somename_en], n.resolve('somename.en.page', 'en'))
-      assert_equal(nodes[:somename_en], n.resolve('somename.en.page', 'de'))
-      assert_equal(nil, n.resolve('somename.fr.page', 'de'))
-
-      assert_equal(nodes[:other], n.resolve('other.page', nil))
-      assert_equal(nodes[:other], n.resolve('other.page', 'fr'))
-      assert_equal(nodes[:other_en], n.resolve('other.page', 'en'))
-      assert_equal(nodes[:other_en], n.resolve('other.en.page', nil))
-      assert_equal(nodes[:other_en], n.resolve('other.en.page', 'de'))
-      assert_equal(nil, n.resolve('other.fr.page', nil))
-      assert_equal(nil, n.resolve('other.fr.page', 'en'))
+      assert_equal(nil, n.resolve('somename.html', nil))
+      assert_equal(nodes[:somename_en], n.resolve('somename.html', 'en'))
+      assert_equal(nodes[:somename_de], n.resolve('somename.html', 'de'))
+      assert_equal(nil, n.resolve('somename.html', 'fr'))
+      assert_equal(nodes[:somename_en], n.resolve('somename.en.html', nil))
+      assert_equal(nodes[:somename_en], n.resolve('somename.en.html', 'en'))
+      assert_equal(nodes[:somename_en], n.resolve('somename.en.html', 'de'))
+      assert_equal(nil, n.resolve('somename.fr.html', 'de'))
+
+      assert_equal(nodes[:other], n.resolve('other.html', nil))
+      assert_equal(nodes[:other], n.resolve('other.html', 'fr'))
+      assert_equal(nodes[:other_en], n.resolve('other.html', 'en'))
+      assert_equal(nodes[:other_en], n.resolve('other.en.html', nil))
+      assert_equal(nodes[:other_en], n.resolve('other.en.html', 'de'))
+      assert_equal(nil, n.resolve('other.fr.html', nil))
+      assert_equal(nil, n.resolve('other.fr.html', 'en'))
     end
 
     assert_equal(nodes[:somename_en_frag], nodes[:somename_en].resolve('#othertest', 'de'))
     assert_equal(nodes[:somename_en_frag], nodes[:somename_en].resolve('#othertest', nil))
     assert_equal(nodes[:somename_en_fragnest], nodes[:somename_en].resolve('#nestedpath', nil))
 
-    assert_equal(nil, nodes[:root].resolve('/somename.page#othertest', nil))
-    assert_equal(nodes[:somename_en_frag], nodes[:root].resolve('/somename.page#othertest', 'en'))
-    assert_equal(nodes[:somename_de_frag], nodes[:root].resolve('/somename.page#othertest', 'de'))
-    assert_equal(nodes[:somename_en_frag], nodes[:root].resolve('/somename.en.page#othertest'))
-    assert_equal(nodes[:somename_de_frag], nodes[:root].resolve('/somename.de.page#othertest'))
+    assert_equal(nil, nodes[:root].resolve('/somename.html#othertest', nil))
+    assert_equal(nodes[:somename_en_frag], nodes[:root].resolve('/somename.html#othertest', 'en'))
+    assert_equal(nodes[:somename_de_frag], nodes[:root].resolve('/somename.html#othertest', 'de'))
+    assert_equal(nodes[:somename_en_frag], nodes[:root].resolve('/somename.en.html#othertest'))
+    assert_equal(nodes[:somename_de_frag], nodes[:root].resolve('/somename.de.html#othertest'))
 
     assert_equal(nil, nodes[:dir2].resolve('index.html'))
     assert_equal(nodes[:dir2_index_en], nodes[:dir2].resolve('index.html', 'en'))
@@ -223,11 +225,11 @@ class TestNode < Test::Unit::TestCase
     nodes = create_default_nodes
 
     assert(!nodes[:dir2_index_en].send(:user_nodes_changed?))
-    nodes[:dir2_index_en]['used_nodes'] = '/some*.page'
+    nodes[:dir2_index_en]['used_nodes'] = '/some*.html'
     assert(nodes[:dir2_index_en].send(:user_nodes_changed?))
-    nodes[:dir2_index_en]['used_nodes'] = '../some*.page'
+    nodes[:dir2_index_en]['used_nodes'] = '../some*.html'
     assert(nodes[:dir2_index_en].send(:user_nodes_changed?))
-    nodes[:dir2_index_en]['used_nodes'] = '/someAA*.page'
+    nodes[:dir2_index_en]['used_nodes'] = '/someAA*.html'
     assert(!nodes[:dir2_index_en].send(:user_nodes_changed?))
     nodes[:dir2_index_en]['used_nodes'] = 'index.de.html'
     assert(nodes[:dir2_index_en].send(:user_nodes_changed?))
@@ -361,7 +363,7 @@ class TestNode < Test::Unit::TestCase
                  nodes[:somename_en].link_to(nodes[:somename_en_frag], 'attr1' => 'val1'))
     assert_equal('<a href="#frag">frag</a>',
                  nodes[:somename_en].link_to(nodes[:somename_en_frag], :attr1 => 'val1'))
-    assert_equal('<a href="dir2/index.html">index</a>',
+    assert_equal('<a href="dir2/index.html">index en</a>',
                  nodes[:somename_en].link_to(nodes[:dir2_index_en]))
 
     nodes[:somename_en_frag]['link_attrs'] = {:link_text => 'Default Text', 'class'=>'help'}
@@ -400,4 +402,63 @@ class TestNode < Test::Unit::TestCase
     assert_equal("http://example.com/test", Webgen::Node.url("http://example.com/test", false).to_s)
   end
 
+  def test_find
+    nodes = create_default_nodes
+
+    check = lambda do |correct, result|
+      assert_equal(correct.collect {|n| nodes[n].alcn }, result.to_list.flatten)
+    end
+
+    check.call([:somename_en, :somename_en_frag, :somename_en_fragnest, :somename_de, :somename_de_frag,
+                :other, :other_en, :dir, :dir_file, :dir_file_frag, :dir2, :dir2_index_en, :dir2_index_de],
+               nodes[:root].find())
+
+    # :levels
+    check.call([],
+               nodes[:root].find(:levels => 0))
+    check.call([:somename_en, :somename_de, :other, :other_en, :dir, :dir2],
+               nodes[:root].find(:levels => 1))
+
+    # :alcn
+    check.call([:somename_en, :somename_en_frag, :somename_en_fragnest, :somename_de, :somename_de_frag,
+                :other, :other_en, :dir, :dir2],
+               nodes[:root].find(:alcn => '*'))
+    check.call([:somename_en, :somename_de, :other, :other_en, :dir, :dir2],
+               nodes[:root].find(:alcn => '*', :levels => 1))
+    check.call([:somename_en, :other_en],
+               nodes[:root].find(:alcn => '/*.en.html'))
+
+    # :sort
+    check.call([:somename_en, :somename_en_frag, :somename_en_fragnest, :somename_de, :somename_de_frag,
+                :other, :other_en, :dir, :dir_file, :dir_file_frag, :dir2, :dir2_index_en, :dir2_index_de],
+               nodes[:root].find(:sort => false))
+    check.call([:dir, :dir_file, :dir_file_frag, :dir2, :dir2_index_en, :dir2_index_de, :other, :other_en,
+                :somename_de, :somename_de_frag, :somename_en, :somename_en_frag, :somename_en_fragnest],
+               nodes[:root].find(:sort => true))
+    check.call([:somename_en, :somename_en_frag, :somename_en_fragnest, :dir, :dir_file, :dir_file_frag, :dir2, :dir2_index_en, :dir2_index_de,
+                :somename_de, :somename_de_frag, :other_en, :other],
+               nodes[:root].find(:sort => 'sort_test'))
+
+    # :limit
+    check.call([:somename_en, :somename_en_frag, :somename_en_fragnest, :somename_de, :somename_de_frag],
+               nodes[:root].find(:limit => 5))
+    check.call([:somename_en, :somename_en_frag, :somename_en_fragnest, :somename_de, :somename_de_frag,
+                :other, :other_en, :dir, :dir_file, :dir_file_frag, :dir2, :dir2_index_en, :dir2_index_de],
+               nodes[:root].find(:limit => 100))
+    check.call([:somename_en, :somename_en_frag, :somename_en_fragnest, :somename_de, :somename_de_frag,
+                :other, :other_en, :dir, :dir_file, :dir_file_frag, :dir2, :dir2_index_en, :dir2_index_de],
+               nodes[:root].find(:limit => 'hallo'))
+
+    # :offset
+    check.call([:somename_en, :somename_en_frag, :somename_en_fragnest, :somename_de, :somename_de_frag,
+                :other, :other_en, :dir, :dir_file, :dir_file_frag, :dir2, :dir2_index_en, :dir2_index_de],
+               nodes[:root].find(:offset => 0))
+    check.call([:other, :other_en, :dir, :dir_file, :dir_file_frag, :dir2, :dir2_index_en, :dir2_index_de],
+               nodes[:root].find(:offset => 5))
+    check.call([:somename_en, :somename_en_frag, :somename_en_fragnest, :somename_de, :somename_de_frag,
+                :other, :other_en, :dir, :dir_file, :dir_file_frag, :dir2, :dir2_index_en, :dir2_index_de],
+               nodes[:root].find(:offset => 'hallo'))
+
+  end
+
 end