rtf 0.1.0

data/test/ColourTableTest.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rtf'
+
+include RTF
+
+# ColourTable class unit test class.
+class ColourTableTest < Test::Unit::TestCase
+   def setup
+      @colours = [Colour.new(0, 0, 0),
+                  Colour.new(100, 100, 100),
+                  Colour.new(150, 150, 150),
+                  Colour.new(200, 200, 200),
+                  Colour.new(250, 250, 250)]
+   end
+
+   def test_01
+      tables = []
+      tables.push(ColourTable.new)
+      tables.push(ColourTable.new(@colours[0], @colours[2]))
+      tables.push(ColourTable.new(*@colours))
+      tables.push(ColourTable.new(@colours[0], @colours[1], @colours[0]))
+
+      assert(tables[0].size == 0)
+      assert(tables[1].size == 2)
+      assert(tables[2].size == 5)
+      assert(tables[3].size == 2)
+
+      assert(tables[0][0] == nil)
+      assert(tables[1][1] == @colours[2])
+      assert(tables[2][3] == @colours[3])
+      assert(tables[3][5] == nil)
+
+      assert(tables[0].index(@colours[1]) == nil)
+      assert(tables[1].index(@colours[2]) == 2)
+      assert(tables[2].index(@colours[3]) == 4)
+      assert(tables[3].index(@colours[4]) == nil)
+
+      tables[0].add(@colours[0])
+      assert(tables[0].size == 1)
+      assert(tables[0].index(@colours[0]) == 1)
+
+      tables[0] << @colours[1]
+      assert(tables[0].size == 2)
+      assert(tables[0].index(@colours[1]) == 2)
+
+      tables[0].add(@colours[1])
+      assert(tables[0].size == 2)
+      assert([tables[0][0], tables[0][1]] == [@colours[0], @colours[1]])
+
+      tables[0] << @colours[0]
+      assert(tables[0].size == 2)
+      assert([tables[0][0], tables[0][1]] == [@colours[0], @colours[1]])
+
+      flags = [false, false, false, false, false]
+      tables[2].each do |colour|
+         flags[@colours.index(colour)] = true if @colours.index(colour) != nil
+      end
+      assert(flags.index(false) == nil)
+
+      assert(tables[0].to_s(2) == "  Colour Table (2 colours)\n"\
+                                  "     Colour (0/0/0)\n"\
+                                  "     Colour (100/100/100)")
+      assert(tables[1].to_s(4) == "    Colour Table (2 colours)\n"\
+                                  "       Colour (0/0/0)\n"\
+                                  "       Colour (150/150/150)")
+      assert(tables[2].to_s(-6) == "Colour Table (5 colours)\n"\
+                                   "   Colour (0/0/0)\n"\
+                                   "   Colour (100/100/100)\n"\
+                                   "   Colour (150/150/150)\n"\
+                                   "   Colour (200/200/200)\n"\
+                                   "   Colour (250/250/250)")
+      assert(tables[3].to_s == "Colour Table (2 colours)\n"\
+                               "   Colour (0/0/0)\n"\
+                               "   Colour (100/100/100)")
+
+      assert(tables[0].to_rtf(3) == "   {\\colortbl\n   ;\n"\
+                                    "   \\red0\\green0\\blue0;\n"\
+                                    "   \\red100\\green100\\blue100;\n"\
+                                    "   }")
+      assert(tables[1].to_rtf(6) == "      {\\colortbl\n      ;\n"\
+                                    "      \\red0\\green0\\blue0;\n"\
+                                    "      \\red150\\green150\\blue150;\n"\
+                                    "      }")
+      assert(tables[2].to_rtf(-9) == "{\\colortbl\n;\n"\
+                                     "\\red0\\green0\\blue0;\n"\
+                                     "\\red100\\green100\\blue100;\n"\
+                                     "\\red150\\green150\\blue150;\n"\
+                                     "\\red200\\green200\\blue200;\n"\
+                                     "\\red250\\green250\\blue250;\n"\
+                                     "}")
+      assert(tables[3].to_rtf == "{\\colortbl\n;\n"\
+                                 "\\red0\\green0\\blue0;\n"\
+                                 "\\red100\\green100\\blue100;\n"\
+                                 "}")
+   end
+end

data/test/ColourTest.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'test/unit'
+require 'rtf'
+
+include RTF
+
+# Colour class unit test class.
+class ColourTest < Test::Unit::TestCase
+   def test_01
+      colours = []
+      colours.push(Colour.new(255, 255, 255))
+      colours.push(Colour.new(200, 0, 0))
+      colours.push(Colour.new(0, 150, 0))
+      colours.push(Colour.new(0, 0, 100))
+      colours.push(Colour.new(0, 0, 0))
+
+      assert(colours[0] == colours[0])
+      assert(!(colours[1] == colours[2]))
+      assert(colours[3] == Colour.new(0, 0, 100))
+      assert(!(colours[4] == 12345))
+
+      assert(colours[0].red == 255)
+      assert(colours[0].green == 255)
+      assert(colours[0].blue == 255)
+
+      assert(colours[1].red == 200)
+      assert(colours[1].green == 0)
+      assert(colours[1].blue == 0)
+
+      assert(colours[2].red == 0)
+      assert(colours[2].green == 150)
+      assert(colours[2].blue == 0)
+
+      assert(colours[3].red == 0)
+      assert(colours[3].green == 0)
+      assert(colours[3].blue == 100)
+
+      assert(colours[4].red == 0)
+      assert(colours[4].green == 0)
+      assert(colours[4].blue == 0)
+
+      assert(colours[0].to_s(3) == '   Colour (255/255/255)')
+      assert(colours[1].to_s(6) == '      Colour (200/0/0)')
+      assert(colours[2].to_s(-20) == 'Colour (0/150/0)')
+      assert(colours[3].to_s == 'Colour (0/0/100)')
+      assert(colours[4].to_s == 'Colour (0/0/0)')
+
+      assert(colours[0].to_rtf(2) == '  \red255\green255\blue255;')
+      assert(colours[1].to_rtf(4) == '    \red200\green0\blue0;')
+      assert(colours[2].to_rtf(-6) == '\red0\green150\blue0;')
+      assert(colours[3].to_rtf == '\red0\green0\blue100;')
+      assert(colours[4].to_rtf == '\red0\green0\blue0;')
+
+      begin
+         Colour.new(256, 0, 0)
+         flunk("Successfully created a colour with an invalid red setting.")
+      rescue RTFError
+      rescue Test::Unit::AssertionFailedError => error
+         raise error
+      rescue => error
+         flunk("Unexpected exception caught. Type: #{error.class.name}\n"\
+               "Message: #{error.message}")
+      end
+
+      begin
+         Colour.new(0, 1000, 0)
+         flunk("Successfully created a colour with an invalid green setting.")
+      rescue RTFError
+      rescue Test::Unit::AssertionFailedError => error
+         raise error
+      rescue => error
+         flunk("Unexpected exception caught. Type: #{error.class.name}\n"\
+               "Message: #{error.message}")
+      end
+
+      begin
+         Colour.new(0, 0, -300)
+         flunk("Successfully created a colour with an invalid blue setting.")
+      rescue RTFError
+      rescue Test::Unit::AssertionFailedError => error
+         raise error
+      rescue => error
+         flunk("Unexpected exception caught. Type: #{error.class.name}\n"\
+               "Message: #{error.message}")
+      end
+
+      begin
+         Colour.new('La la la', 0, 0)
+         flunk("Successfully created a colour with an invalid red type.")
+      rescue RTFError
+      rescue Test::Unit::AssertionFailedError => error
+         raise error
+      rescue => error
+         flunk("Unexpected exception caught. Type: #{error.class.name}\n"\
+               "Message: #{error.message}")
+      end
+
+      begin
+         Colour.new(0, {}, 0)
+         flunk("Successfully created a colour with an invalid green type.")
+      rescue RTFError
+      rescue Test::Unit::AssertionFailedError => error
+         raise error
+      rescue => error
+         flunk("Unexpected exception caught. Type: #{error.class.name}\n"\
+               "Message: #{error.message}")
+      end
+
+      begin
+         Colour.new(0, 0, [])
+         flunk("Successfully created a colour with an invalid blue type.")
+      rescue RTFError
+      rescue Test::Unit::AssertionFailedError => error
+         raise error
+      rescue => error
+         flunk("Unexpected exception caught. Type: #{error.class.name}\n"\
+               "Message: #{error.message}")
+      end
+   end
+end

data/test/CommandNodeTest.rb

@@ -0,0 +1,220 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'test/unit'
+require 'rtf'
+
+include RTF
+
+# Information class unit test class.
+class CommandNodeTest < Test::Unit::TestCase
+   def test_basics
+      nodes = []
+      nodes.push(CommandNode.new(nil, 'prefix'))
+      nodes.push(CommandNode.new(nil, '', 'lalala'))
+      nodes.push(CommandNode.new(nodes[0], '', nil, false))
+
+      assert(nodes[0].prefix == 'prefix')
+      assert(nodes[1].prefix == '')
+      assert(nodes[2].prefix == '')
+
+      assert(nodes[0].suffix == nil)
+      assert(nodes[1].suffix == 'lalala')
+      assert(nodes[2].suffix == nil)
+
+      assert(nodes[0].split == true)
+      assert(nodes[1].split == true)
+      assert(nodes[2].split == false)
+   end
+
+   # Test line breaks.
+   def test_line_break
+      root = CommandNode.new(nil, nil)
+
+      assert(root.line_break == nil)
+      assert(root.size == 1)
+      assert(root[0].class == CommandNode)
+      assert(root[0].prefix == '\line')
+      assert(root[0].suffix == nil)
+      assert(root[0].split == false)
+   end
+
+   # Test paragraphs.
+   def test_paragraph
+      root  = CommandNode.new(nil, nil)
+      style = ParagraphStyle.new
+
+      assert(root.paragraph(style) != nil)
+      assert(root.size == 1)
+      assert(root[0].class == CommandNode)
+      assert(root[0].prefix == '\pard\ql')
+      assert(root[0].suffix == '\par')
+      assert(root.split == true)
+
+      style.justification = ParagraphStyle::RIGHT_JUSTIFY
+      assert(root.paragraph(style).prefix == '\pard\qr')
+
+      style.justification = ParagraphStyle::CENTRE_JUSTIFY
+      assert(root.paragraph(style).prefix == '\pard\qc')
+
+      style.justification = ParagraphStyle::FULL_JUSTIFY
+      assert(root.paragraph(style).prefix == '\pard\qj')
+
+      style.justification = ParagraphStyle::LEFT_JUSTIFY
+      style.space_before = 100
+      root.paragraph(style)
+      assert(root[-1].prefix == '\pard\ql\sb100')
+
+      style.space_before = nil
+      style.space_after  = 1234
+      root.paragraph(style)
+      assert(root[-1].prefix == '\pard\ql\sa1234')
+
+      style.space_before = nil
+      style.space_after  = nil
+      style.left_indent  = 10
+      root.paragraph(style)
+      assert(root[-1].prefix == '\pard\ql\li10')
+
+      style.space_before = nil
+      style.space_after  = nil
+      style.left_indent  = nil
+      style.right_indent = 234
+      root.paragraph(style)
+      assert(root[-1].prefix == '\pard\ql\ri234')
+
+      style.space_before      = nil
+      style.space_after       = nil
+      style.left_indent       = nil
+      style.right_indent      = nil
+      style.first_line_indent = 765
+      root.paragraph(style)
+      assert(root[-1].prefix == '\pard\ql\fi765')
+
+      style.space_before      = 12
+      style.space_after       = 23
+      style.left_indent       = 34
+      style.right_indent      = 45
+      style.first_line_indent = 56
+      root.paragraph(style)
+      assert(root[-1].prefix == '\pard\ql\li34\ri45\fi56\sb12\sa23')
+
+      node = nil
+      root.paragraph(style) {|n| node = n}
+      assert(node == root[-1])
+   end
+
+   # Test applications of styles.
+   def test_style
+      root  = Document.new(Font.new(Font::ROMAN, 'Arial'))
+      style = CharacterStyle.new
+      style.bold = true
+
+      assert(root.apply(style) != nil)
+      assert(root.size == 1)
+      assert(root[0].class == CommandNode)
+      assert(root[0].prefix == '\b')
+      assert(root[0].suffix == nil)
+      assert(root[0].split == true)
+
+      style.underline = true
+      assert(root.apply(style).prefix == '\b\ul')
+
+      style.bold        = false
+      style.superscript = true
+      assert(root.apply(style).prefix == '\ul\super')
+
+      style.underline = false
+      style.italic    = true
+      assert(root.apply(style).prefix == '\i\super')
+
+      style.italic = false
+      style.bold   = true
+      assert(root.apply(style).prefix == '\b\super')
+
+      style.bold        = false
+      style.superscript = false
+      style.italic      = true
+      style.font_size   = 20
+      assert(root.apply(style).prefix == '\i\fs20')
+
+      node = nil
+      root.apply(style) {|n| node = n}
+      assert(node == root[-1])
+
+      # Test style short cuts.
+      node = root.bold
+      assert(node.prefix == '\b')
+      assert(node.suffix == nil)
+      assert(node == root[-1])
+
+      node = root.italic
+      assert(node.prefix == '\i')
+      assert(node.suffix == nil)
+      assert(node == root[-1])
+
+      node = root.underline
+      assert(node.prefix == '\ul')
+      assert(node.suffix == nil)
+      assert(node == root[-1])
+
+      node = root.superscript
+      assert(node.prefix == '\super')
+      assert(node.suffix == nil)
+      assert(node == root[-1])
+   end
+
+   # Test text node addition.
+   def test_text
+      root = CommandNode.new(nil, nil)
+
+      root << 'A block of text.'
+      assert(root.size == 1)
+      assert(root[0].class == TextNode)
+      assert(root[0].text == 'A block of text.')
+
+      root << " More text."
+      assert(root.size == 1)
+      assert(root[0].class == TextNode)
+      assert(root[0].text == 'A block of text. More text.')
+
+      root.paragraph
+      root << "A new node."
+      assert(root.size == 3)
+      assert(root[0].class == TextNode)
+      assert(root[-1].class == TextNode)
+      assert(root[0].text == 'A block of text. More text.')
+      assert(root[-1].text == 'A new node.')
+   end
+
+   # Test table addition.
+   def test_table
+      root  = CommandNode.new(nil, nil)
+
+      table = root.table(3, 3, 100, 150, 200)
+      assert(root.size == 1)
+      assert(root[0].class == TableNode)
+      assert(root[0] == table)
+      assert(table.rows == 3)
+      assert(table.columns == 3)
+
+      assert(table[0][0].width == 100)
+      assert(table[0][1].width == 150)
+      assert(table[0][2].width == 200)
+   end
+
+   # This test checks the previous_node and next_node methods that could not be
+   # fully and properly checked in the NodeTest.rb file.
+   def test_peers
+      root  = Document.new(Font.new(Font::ROMAN, 'Arial'))
+      nodes = []
+      nodes.push(root.paragraph)
+      nodes.push(root.bold)
+      nodes.push(root.underline)
+
+      assert(root.previous_node == nil)
+      assert(root.next_node == nil)
+      assert(nodes[1].previous_node == nodes[0])
+      assert(nodes[1].next_node == nodes[2])
+   end
+end

data/test/ContainerNodeTest.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'test/unit'
+require 'rtf'
+
+include RTF
+
+# Information class unit test class.
+class ContainerNodeTest < Test::Unit::TestCase
+   def test01
+      nodes = []
+      nodes.push(ContainerNode.new(nil))
+      nodes.push(ContainerNode.new(nodes[0]))
+      
+      assert(nodes[0].size == 0)
+      assert(nodes[1].size == 0)
+      
+      assert(nodes[0].first == nil)
+      assert(nodes[0].last == nil)
+      assert(nodes[1].first == nil)
+      assert(nodes[1].last == nil)
+      
+      assert(nodes[0][0] == nil)
+      assert(nodes[1][-1] == nil)
+      
+      count = 0
+      nodes[0].each {|entry| count += 1}
+      assert(count == 0)
+      nodes[1].each {|entry| count += 1}
+      assert(count == 0)
+   end
+   
+   def test02
+      node   = ContainerNode.new(nil)
+      child1 = ContainerNode.new(nil)
+      child2 = ContainerNode.new(nil)
+      
+      node.store(child1)
+      assert(node.size == 1)
+      assert(node[0] == child1)
+      assert(node[-1] == child1)
+      assert(node[0].parent == node)
+      assert(node.first == child1)
+      assert(node.last == child1)
+      
+      count = 0
+      node.each {|entry| count += 1}
+      assert(count == 1)
+      
+      node.store(child2)
+      assert(node.size == 2)
+      assert(node[0] == child1)
+      assert(node[1] == child2)
+      assert(node[-1] == child2)
+      assert(node[-2] == child1)
+      assert(node[0].parent == node)
+      assert(node[1].parent == node)
+      assert(node.first == child1)
+      assert(node.last == child2)
+   end
+   
+   def test03
+      begin
+         ContainerNode.new(nil).to_rtf
+         flunk("Successfully called ContainerNode#to_rtf().")
+      rescue => error
+      end
+   end
+end