webgen 0.4.7 → 0.5.0

data/test/unittests/tc_filehandler_directory.rb

@@ -1,134 +0,0 @@
-require 'fileutils'
-require 'webgen/test'
-
-class DirNodeTest < Webgen::PluginTestCase
-
-  plugin_files [
-    'webgen/plugins/filehandlers/directory.rb'
-  ]
-
-  def test_accessors
-    dir = @wrapper::FileHandlers::DirectoryHandler::DirNode.new( nil, 'dir/', {'test'=>'test'} )
-    assert_equal( 'Dir', dir['title'] )
-    assert_equal( 'test', dir['test'] )
-  end
-
-  def test_order_info
-    dir = @wrapper::FileHandlers::DirectoryHandler::DirNode.new( nil, 'dir/' )
-    dir.node_info[:processor] = @manager['File/DirectoryHandler']
-
-    assert_equal( 0, dir.order_info )
-
-    index = Node.new( dir, 'index.page' )
-    dir.meta_info.delete( 'indexFile' )
-    assert_equal( 0, dir.order_info )
-
-    dir['indexFile'] = 'index.page'
-    index['orderInfo'] = 1
-    assert_equal( 0, dir.order_info )
-
-    dir['orderInfo'] = 2
-    assert_equal( 2, dir.order_info )
-  end
-
-  def test_index_file
-    dir = @wrapper::FileHandlers::DirectoryHandler::DirNode.new( nil, 'dir/' )
-    dir.node_info[:processor] = @manager['File/DirectoryHandler']
-
-    assert_nil( dir['indexFile'] )
-
-    index = Node.new( dir, 'index.page' )
-
-    dir['indexFile'] = index
-    assert_equal( index, dir['indexFile'] )
-
-    dir['indexFile'] = 'index.page'
-    assert_equal( index, dir['indexFile'] )
-
-    dir['indexFile'] = 'index1.page'
-    assert_equal( nil, dir['indexFile'] )
-    dir['indexFile'] = 'index1.page'
-    index.path = 'index1.page'
-    assert_equal( index, dir['indexFile'] )
-
-    index.path = 'index.page'
-    dir['indexFile'] = nil
-    assert_equal( nil, dir['indexFile'] )
-  end
-
-end
-
-class DirectoryHandlerTest < Webgen::PluginTestCase
-
-  plugin_files [
-    'webgen/plugins/filehandlers/directory.rb',
-    base_fixture_path( 'tc_filehandler_filehandler/sample_plugin.rb' )
-  ]
-  plugin_to_test 'File/DirectoryHandler'
-
-  def setup
-    super
-    @dirs = find_in_sample_site {|path| path =~ /\/$/ }.collect {|p| p.sub(/^#{sample_site( Webgen::SRC_DIR )}/, sample_site( 'out' ) )}
-    @root_dir = @dirs.min
-    @max_dir = @dirs.max
-  end
-
-  def test_create_node
-    root = @plugin.create_node( @root_dir, nil, {} )
-    assert_equal( @plugin, root.node_info[:processor] )
-    assert_equal( @root_dir, root.node_info[:src] )
-    dir = @plugin.create_node( @max_dir, root, {'test'=>'yes'} )
-    assert_equal( 'yes', dir['test'] )
-    dir1 = @plugin.create_node( @max_dir, root, {'test'=>'no'} )
-    assert_equal( 'yes', dir1['test'] )
-    assert_same( dir, dir1 )
-    assert_equal( File.basename( @max_dir ).capitalize, dir['title'] )
-  end
-
-  def test_write_node
-    root = @plugin.create_node( @root_dir, nil, {} )
-    root.path = @root_dir
-    dir_node = @plugin.create_node( @max_dir, root, {} )
-    dir_node.write_node
-    assert( File.directory?( dir_node.full_path ) )
-  ensure
-    FileUtils.rm_r( @root_dir, :force => true )
-  end
-
-  def test_recursive_create_path
-    root = @plugin.create_node( @root_dir, nil, {} )
-    root.path = @root_dir
-    root.node_info[:src] = @root_dir
-    dir_node = @plugin.recursive_create_path( @max_dir.sub( /^#{@root_dir}/, '' ), root )
-    dir_node.write_node
-    assert( File.directory?( @max_dir ) )
-  ensure
-    FileUtils.rm_r( @root_dir, :force => true )
-  end
-
-  def test_node_for_lang
-    # directory with index file
-    root = @manager['Core/FileHandler'].instance_eval { build_tree }
-    assert_equal( root.resolve_node( 'index.en.html' ), root.node_for_lang( Webgen::LanguageManager.language_for_code( 'en' ) ) )
-    assert_equal( root.resolve_node( 'index.de.html' ), root.node_for_lang( Webgen::LanguageManager.language_for_code( 'de' ) ) )
-
-    # directory without index file
-    dir1 = root.resolve_node( 'dir1' )
-    assert_equal( dir1, dir1.node_for_lang( Webgen::LanguageManager.language_for_code( 'de' ) ) )
-  end
-
-  def test_link_from
-    root = @manager['Core/FileHandler'].instance_eval { build_tree }
-
-    file11 = root.resolve_node( 'dir1/file11.html' )
-    assert_equal( '<a href="../index.en.html"></a>', root.link_from( file11 ) )
-    assert_equal( '<span>TestLink</span>',
-                  root.link_from( root.resolve_node( 'index.de.html' ), {:link_text => 'TestLink' } ) )
-
-    dir1 = root.resolve_node( 'dir1' )
-    assert_equal( '<a href="./">Dir1</a>', dir1.link_from( file11 ) )
-    assert_equal( '<a href="dir1/">TestLink</a>', dir1.link_from( root, {:link_text => 'TestLink' } ) )
-  end
-
-end
-

data/test/unittests/tc_filehandler_filehandler.rb

@@ -1,294 +0,0 @@
-require 'find'
-require 'fileutils'
-require 'webgen/test'
-require 'webgen/node'
-require 'webgen/config'
-
-class FileHandlerTest < Webgen::PluginTestCase
-
-  #TODO think about runtime depdencies  (e.g. Configuration for Core/FileHandler)
-  #     ie. ones which are not required for initializing, but for running
-  plugin_files [
-    'webgen/plugins/filehandlers/filehandler.rb',
-    'webgen/plugins/filehandlers/directory.rb',
-    fixture_path( 'sample_plugin.rb' ),
-  ]
-  plugin_to_test 'Core/FileHandler'
-
-  def setup
-    @websiteDir = nil
-    super
-  end
-
-  def param_for_plugin( plugin_name, param )
-    if [plugin_name, param] == ['Core/Configuration', 'websiteDir'] && @websiteDir
-      @websiteDir
-    else
-      super
-    end
-  end
-
-  def test_file_modified
-    modified = fixture_path( 'modified' )
-    unmodified = fixture_path( 'unmodified' )
-
-    assert( @plugin.file_modified?( unmodified, modified ) )
-    assert( !@plugin.file_modified?( unmodified, unmodified ) )
-    FileUtils.touch( modified )
-    assert( !@plugin.file_modified?( unmodified, modified ) )
-    assert( @plugin.file_modified?( modified, unmodified ) )
-  ensure
-    FileUtils.rm( modified, :force => true )
-  end
-
-  def test_find_all_files
-    found_files = @plugin.instance_eval {find_all_files}
-    files = find_in_sample_site {|p| p != sample_site( Webgen::SRC_DIR ) + '/' }
-    assert_equal( files, found_files )
-  end
-
-  def test_find_files_for_handlers
-    files_for_handlers = @plugin.instance_eval {find_files_for_handlers}
-    files = find_in_sample_site {|path| path =~ /\.page$/}
-
-    assert_equal( 2, files_for_handlers.length )
-    files_for_sample_handler = files_for_handlers.select {|r,p,f| p == @manager['SampleHandler']}
-    assert_not_nil( files_for_sample_handler )
-    assert_equal( files, files_for_sample_handler.first[2] )
-  end
-
-  def test_create_root_node
-    srcDir = @manager.param_for_plugin( 'Core/Configuration', 'srcDir' ) + '/'
-    outDir = @manager.param_for_plugin( 'Core/Configuration', 'outDir' ) + '/'
-
-    dir_handler = @manager.plugins.delete( 'File/DirectoryHandler' )
-    root = @plugin.instance_eval {create_root_node}
-    assert_nil( root )
-
-    @manager.plugins['File/DirectoryHandler'] = dir_handler
-    root = @plugin.instance_eval {create_root_node}
-    assert_kind_of( Node, root )
-    assert_equal( '', root['title'] )
-    assert_equal( outDir, root.path )
-    assert_equal( root.path, root.full_path )
-    assert_equal( srcDir, root.node_info[:src] )
-  end
-
-  def test_create_node_dir
-    dirs = find_in_sample_site {|path| File.directory?(path)}
-
-    root_node = @plugin.instance_eval {create_root_node}
-    dir_handler = @manager['File/DirectoryHandler']
-
-    max_dir = dirs.max
-
-    dir = @plugin.create_node( max_dir.sub( /^#{root_node.node_info[:src]}/, ''), root_node, dir_handler )
-    assert_not_nil( dir )
-    assert_equal( File.join( File.basename( max_dir ), '/' ), dir.path )
-    assert_equal( max_dir.sub(/^#{root_node.node_info[:src]}/, root_node.path), dir.full_path )
-    assert( dir.is_directory? )
-
-    n = root_node
-    while n.has_children?
-      assert( n.is_directory? )
-      assert_equal( 1, n.children.length, "node: #{n.children.collect{|c| c.path}.inspect}" )
-      n = n.children[0]
-    end
-
-    dir1 = @plugin.create_node( max_dir.sub( /^#{root_node.node_info[:src]}/, ''), root_node, dir_handler )
-    assert_same( dir, dir1 )
-  end
-
-  def test_create_node_file
-    pages = find_in_sample_site {|path| path =~ /\.page$/}
-
-    root_node = @plugin.instance_eval {create_root_node}
-    dir_handler = @manager['File/DirectoryHandler']
-    page_handler = @manager['SampleHandler']
-
-    max_page = pages.max
-    page = @plugin.create_node( max_page.sub( /^#{root_node.node_info[:src]}/, ''), root_node, page_handler )
-    assert_not_nil( page )
-    max_page_outpath = File.join( File.dirname( max_page.sub(/^#{root_node.node_info[:src]}/, root_node.path) ),
-                                  page_handler.class.out_name( max_page ) )
-    assert_equal( max_page_outpath, page.full_path )
-    assert( page.is_file? )
-
-    page1 = @plugin.create_node( max_page.sub( /^#{root_node.node_info[:src]}/, ''), root_node, page_handler )
-    assert_same( page, page1 )
-  end
-
-  def test_build_tree
-    outDir = @manager.param_for_plugin( 'Core/Configuration', 'outDir' ) + '/'
-
-    tree = @plugin.instance_eval {build_tree}
-    assert_not_nil( tree )
-    assert_equal( outDir, tree.full_path )
-    assert_equal( 6, tree.children.size )
-    assert_not_nil( tree.resolve_node( 'dir1/dir11/file111.html' ) )
-
-    nr_paths_on_disc = find_in_sample_site {|p| true }.length
-
-    def calc_length( tree ); tree.children.inject( 1 ) {|memo,c| memo += calc_length( c ) }; end
-
-    assert( calc_length( tree ), nr_paths_on_disc )
-  end
-
-  def test_load_meta_info_backing_file
-    @websiteDir = fixture_path('backing')
-    assert( File.exists?( @websiteDir ) )
-    @plugin.instance_eval { load_meta_info_backing_file }
-    assert_equal({'key1'=>'value1'}, @plugin.instance_eval { @source_backing['/file1'] })
-    assert_equal({}, @plugin.instance_eval { @output_backing })
-    @websiteDir = fixture_path('backing_empty')
-    assert( File.exists?( @websiteDir ) )
-    @plugin.instance_eval { @source_backing = nil; @output_backing = nil; load_meta_info_backing_file }
-    assert_equal({}, @plugin.instance_eval { @source_backing })
-  ensure
-    @websiteDir = nil
-  end
-
-  def test_meta_info_for
-    @plugin.instance_eval { @source_backing = {'/file'=>{'key'=>'novalue'},'ile'=>{'key'=>'false value'}} }
-    assert_equal( {'key'=>'value'}, @plugin.meta_info_for( @manager['SampleHandler'] ) )
-    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], '/file' ) )
-    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], 'file' ) )
-
-    @plugin.instance_eval { @source_backing = {'/file'=>{'key'=>'novalue'}} }
-    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], '/file' ) )
-    assert_equal( {'key'=>'value'}, @plugin.meta_info_for( @manager['SampleHandler'] ) )
-
-    @plugin.instance_eval { @source_backing = {'/dir'=>{'key'=>'novalue'}} }
-    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], 'dir' ) )
-    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], '/dir/' ) )
-    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], '/dir' ) )
-    assert_equal( {'key'=>'novalue'}, @plugin.meta_info_for( @manager['SampleHandler'], 'dir/' ) )
-  end
-
-  def test_handle_output_backing
-    root = @plugin.instance_eval { create_root_node }
-    node = Node.new( Node.new( root, 'dir/' ), 'test1.html' )
-    node['test'] = 'yes'
-    @plugin.instance_eval { @output_backing = {
-        'api.html'=>{'url'=>'rdoc/index.html'},
-        '/doc/test.html'=>{'url'=>'http://www.webgen.com'},
-        'dir/test1.html'=>{'test'=>'no'}
-      }}
-    @plugin.instance_eval { handle_output_backing( root ) }
-
-    # test virtual node creation
-    assert_not_nil( root.resolve_node( 'rdoc/index.html' ) )
-    assert_not_nil( root.resolve_node( 'api.html' ) )
-    backed1 = root.resolve_node( 'api.html' )
-    assert_equal( 'api.html', backed1.node_info[:reference] )
-    assert_equal( @manager['File/VirtualFileHandler'], backed1.node_info[:processor] )
-
-    backed2 = root.resolve_node( 'doc/test.html' )
-    assert_not_nil( backed2 )
-
-    assert_equal( '<a href="../rdoc/index.html">rdoc/index.html</a>', backed1.link_from( node ) )
-    assert_equal( '<a href="http://www.webgen.com">http://www.webgen.com</a>', backed2.link_from( node ) )
-
-    # test setting of meta infos for existing nodes
-    assert_equal( 1, root.resolve_node( 'dir/' ).children.length )
-    assert_equal( 'no', node['test'] )
-  end
-
-end
-
-class DefaultHandlerTest < Webgen::PluginTestCase
-
-  plugin_files ['webgen/plugins/filehandlers/filehandler.rb']
-  plugin_to_test 'File/DefaultHandler'
-
-  def setup
-    super
-    @defHandlerClass = @manager.plugin_class_for_name( 'File/DefaultHandler' )
-    @plugin1 = @defHandlerClass.new( @manager )
-  end
-
-  def param_for_plugin( plugin_name, param )
-    if [plugin_name, param] == ['File/DefaultHandler', 'linkToCurrentPage'] && @link_to_current
-      @link_to_current
-    else
-      super
-    end
-  end
-
-  def test_initialization
-    assert_nil( @plugin )
-  end
-
-  def test_accessors
-    @defHandlerClass.class_eval do
-      register_path_pattern 'first'
-      register_path_pattern 'second', 10
-      register_extension 'fff'
-      register_extension 'ggg', 20
-
-      public :register_extension
-      public :register_path_pattern
-    end
-    @plugin1.register_path_pattern 'third'
-    @plugin1.register_path_pattern 'fourth', 30
-    @plugin1.register_extension 'hhh'
-    @plugin1.register_extension 'iii', 40
-
-    patterns = @plugin1.path_patterns.sort
-    [
-     [10, 'second'],
-     [20, @defHandlerClass::EXTENSION_PATH_PATTERN % ['ggg']],
-     [30, 'fourth'],
-     [40, @defHandlerClass::EXTENSION_PATH_PATTERN % ['iii']],
-     [@defHandlerClass::DEFAULT_RANK, 'first'],
-     [@defHandlerClass::DEFAULT_RANK, 'third'],
-     [@defHandlerClass::DEFAULT_RANK, @defHandlerClass::EXTENSION_PATH_PATTERN % ['fff']],
-     [@defHandlerClass::DEFAULT_RANK, @defHandlerClass::EXTENSION_PATH_PATTERN % ['hhh']]
-    ].each_with_index do |p, index|
-      if p[0] == @defHandlerClass::DEFAULT_RANK
-        assert( patterns.include?( p ), "#{p} missing" )
-      else
-        assert_equal( p, patterns[index] )
-      end
-    end
-  end
-
-  def test_methods_for_subclasses
-    assert_raise( NotImplementedError ) { @plugin1.create_node( nil, nil, nil ) }
-    assert_raise( NotImplementedError ) { @plugin1.write_node( nil ) }
-  end
-
-  def test_node_for_lang
-    node = Node.new( nil, 'path' )
-    de = Webgen::LanguageManager.language_for_code( 'de' )
-    en = Webgen::LanguageManager.language_for_code( 'en' )
-    assert_equal( node, @plugin1.node_for_lang( node, de ) )
-    assert_equal( node, @plugin1.node_for_lang( node, en ) )
-  end
-
-  def test_link_from
-    refNode = Node.new( nil, 'path' )
-    node = Node.new( refNode, '#frag' )
-    node['title'] = 'title'
-
-    assert_equal( '<a href="#frag">title</a>', @plugin1.link_from( node, refNode ) )
-    assert_equal( '<a href="#frag">link_text</a>',
-                  @plugin1.link_from( node, refNode, :link_text => 'link_text' ) )
-    assert_equal( '<a attr1="val1" href="#frag">link_text</a>',
-                  @plugin1.link_from( node, refNode, :link_text => 'link_text', 'attr1' => 'val1' ) )
-    assert_equal( '<a href="#frag">link_text</a>',
-                  @plugin1.link_from( node, refNode, :link_text => 'link_text', :attr1 => 'val1' ) )
-
-    node['linkAttrs'] = {:link_text => 'Default Text', 'class'=>'help'}
-    assert_equal( '<a attr1="val1" class="help" href="#frag">link_text</a>',
-                  @plugin1.link_from( node, refNode, :link_text => 'link_text', 'attr1' => 'val1' ) )
-
-    # Test param setting
-    node['linkAttrs'] = nil
-    @link_to_current = true
-    assert_equal( '<a href="#frag">title</a>', @plugin1.link_from( node, node ) )
-    @link_to_current = false
-    assert_equal( '<span>title</span>', @plugin1.link_from( node, node ) )
-  end
-
-end

data/test/unittests/tc_filehandler_gallery.rb

@@ -1,165 +0,0 @@
-require 'webgen/test'
-
-class GalleryInfoTest < Webgen::PluginTestCase
-
-  plugin_files [
-    'webgen/plugins/filehandlers/gallery.rb',
-  ]
-
-  def setup
-    super
-    @ginfoclass = @wrapper::FileHandlers::GalleryHandler::GalleryInfo
-    @iclass = @wrapper::FileHandlers::GalleryHandler::GalleryInfo::Image
-    @gclass = @wrapper::FileHandlers::GalleryHandler::GalleryInfo::Gallery
-    @galleries = []
-    @galleries << @gclass.new( 'gal1.html', {},
-                              [@iclass.new( 'test1.html', {'thumbnail' => 'tn_test1.jpg'}, 'test1.jpg' ), @iclass.new( 'test2.html', {'thumbnailSize' => '100x50'}, 'test2.jpg' )] )
-    @galleries << @gclass.new( 'gal2.html', {},
-                              [@iclass.new( 'test3.html', {}, 'test3.jpg' ), @iclass.new( 'test4.html', {}, 'test4.jpg' )] )
-    @galleries << @gclass.new( 'gal3.html', {},
-                              [@iclass.new( 'test5.html', {}, 'test5.jpg' ), @iclass.new( 'test6.html', {}, 'test6.jpg' )] )
-  end
-
-  def create_ginfo( gindex = nil, iindex = nil )
-    @ginfoclass.new( {:galleries => @galleries}, gindex, iindex )
-  end
-
-  def test_cur_image
-    assert_equal( @galleries[0].images[0], create_ginfo( 0, 0 ).cur_image )
-  end
-
-  def test_cur_gallery
-    assert_equal( @galleries[0], create_ginfo( 0 ).cur_gallery )
-  end
-
-  def test_prev_image
-    assert_equal( nil, create_ginfo( 0, 0 ).prev_image )
-    assert_equal( @galleries[0].images[0], create_ginfo( 0, 1 ).prev_image )
-    assert_equal( @galleries[0].images[1], create_ginfo( 1, 0 ).prev_image )
-  end
-
-  def test_next_image
-    assert_equal( nil, create_ginfo( 2, 1 ).next_image )
-    assert_equal( @galleries[0].images[1], create_ginfo( 0, 0 ).next_image )
-    assert_equal( @galleries[1].images[0], create_ginfo( 0, 1 ).next_image )
-  end
-
-  def test_prev_gallery
-    assert_equal( nil, create_ginfo( 0 ).prev_gallery )
-    assert_equal( @galleries[0], create_ginfo( 1 ).prev_gallery )
-  end
-
-  def test_next_gallery
-    assert_equal( nil, create_ginfo( 2 ).next_gallery )
-    assert_equal( @galleries[1], create_ginfo( 0 ).next_gallery )
-  end
-
-  def test_image_accessors
-    ginfo = create_ginfo( 0, 0 )
-    assert_equal( '<img src="{relocatable: tn_test1.jpg}" alt="" />', ginfo.cur_image.thumbnail )
-    assert_equal( '<img src="{relocatable: test2.jpg}" width="100" height="50" alt="" />', ginfo.next_image.thumbnail )
-  end
-
-  def test_gallery_accessors
-    ginfo = create_ginfo( 0, 0 )
-    assert_equal( '<img src="{relocatable: tn_test1.jpg}" alt="" />', ginfo.cur_gallery.thumbnail )
-    assert_equal( '<img src="{relocatable: test3.jpg}" width="" height="" alt="" />', ginfo.next_gallery.thumbnail )
-  end
-
-end
-
-class GalleryFileHandlerTest < Webgen::PluginTestCase
-
-  plugin_files [
-    'webgen/plugins/filehandlers/directory.rb',
-    'webgen/plugins/filehandlers/gallery.rb'
-  ]
-  plugin_to_test 'File/GalleryHandler'
-
-  def test_param
-    assert_nothing_raised { @plugin.instance_eval { param('imagesPerPage') } }
-  end
-
-  def test_create_node
-    ginfoclass = @wrapper::FileHandlers::GalleryHandler::GalleryInfo
-
-    root = Node.new( nil, '/' )
-    root.node_info[:src] = fixture_path
-
-    # with a main page
-    assert_nil( @plugin.create_node( fixture_path( 'test.gallery' ), root, {} ) )
-    assert_not_nil( root.resolve_node( 'test.page' ) )
-    assert_not_nil( root.resolve_node( 'test_1.page' ) )
-    assert_not_nil( root.resolve_node( 'test_2.page' ) )
-    assert_not_nil( root.resolve_node( 'test_test1_jpg.page' ) )
-    assert_not_nil( root.resolve_node( 'test_test2_jpg.page' ) )
-    assert_not_nil( root.resolve_node( 'test_test3_jpg.page' ) )
-    assert_not_nil( root.resolve_node( 'test_test4_jpg.page' ) )
-
-    node = root.resolve_node( 'test_test3_jpg.page' )
-    assert_kind_of( ginfoclass, node.node_info[:ginfo] )
-    assert_equal( 'test3.jpg', node.node_info[:ginfo].cur_image.filename )
-    assert_equal( node.path, node.node_info[:ginfo].cur_image.pagename )
-    assert_equal( 'gallery_image.template', node['template'] )
-
-    node = root.resolve_node( 'test_2.page' )
-    assert_kind_of( ginfoclass, node.node_info[:ginfo] )
-    assert_equal( node.path, node.node_info[:ginfo].cur_gallery.pagename )
-    assert_equal( 'gallery_gallery.template', node['template'] )
-
-    node = root.resolve_node( 'test.page' )
-    assert_kind_of( ginfoclass, node.node_info[:ginfo] )
-    assert_equal( 'gallery_main.template', node['template'] )
-
-    # without a main page
-    root.del_children
-    @plugin.create_node( fixture_path( 'test1.gallery' ), root, {} )
-    assert_not_nil( root.resolve_node( 'test1.page' ) )
-    assert_nil( root.resolve_node( 'test1_1.page' ) )
-    assert_nil( root.resolve_node( 'test1_2.page' ) )
-    assert_not_nil( root.resolve_node( 'test1_test1_jpg.page' ) )
-    assert_not_nil( root.resolve_node( 'test1_test2_jpg.page' ) )
-    assert_not_nil( root.resolve_node( 'test1_test3_jpg.page' ) )
-    assert_not_nil( root.resolve_node( 'test1_test4_jpg.page' ) )
-
-    node = root.resolve_node( 'test1.page' )
-    assert_kind_of( ginfoclass, node.node_info[:ginfo] )
-    assert_equal( 'gallery_gallery.template', node['template'] )
-  end
-
-end
-
-begin
-
-  require 'RMagick'
-
-  class ThumbnailWriterTest < Webgen::PluginTestCase
-
-    plugin_files [
-                  'webgen/plugins/filehandlers/directory.rb',
-                  'webgen/plugins/filehandlers/gallery.rb'
-                 ]
-    plugin_to_test 'File/ThumbnailWriter'
-
-    def test_create_node
-      node = @plugin.create_node( 'testfor anddo.jpg', nil, {}, '100x100' )
-      assert_equal( 'tn_testfor_anddo.jpg', node.path )
-      assert_equal( 'testfor anddo.jpg', node.node_info[:thumbnail_file] )
-      assert_equal( '100x100', node.node_info[:thumbnail_size] )
-    end
-
-    def test_gallery_thumbnail_creation
-      root = Node.new( nil, '/' )
-      root.node_info[:src] = fixture_path
-
-      @manager['File/GalleryHandler'].create_node( fixture_path( 'test.gallery' ), root, {} )
-      tn_node = root.resolve_node( 'tn_test1.jpg' )
-      assert_not_nil( tn_node )
-      assert_equal( fixture_path( 'test1.jpg' ), tn_node.node_info[:thumbnail_file] )
-      assert_equal( tn_node.absolute_path, root.resolve_node( 'test_test1_jpg.page' ).node_info[:ginfo].cur_image.data['thumbnail'] )
-    end
-
-  end
-
-rescue LoadError
-end