Merge branch '0.24.x' of git://reductivelabs.com/puppet into 0.24.x

1 files changed, 0 insertions, 276 deletions

diff --git a/test/language/lexer.rb b/test/language/lexer.rb
deleted file mode 100755
index e09828d51..000000000
--- a/test/language/lexer.rb
+++ /dev/null
@@ -1,276 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../lib/puppettest'
-
-require 'puppet'
-require 'puppet/parser/lexer'
-require 'puppettest'
-
-#%q{service("telnet") = \{
-#    port => "23",
-#    protocol => "tcp",
-#    name => "telnet",
-#\}
-#} => [[:NAME, "service"], [:LPAREN, "("], [:DQUOTE, "\""], [:NAME, "telnet"], [:DQUOTE, "\""], [:RPAREN, ")"], [:EQUALS, "="], [:lbrace, "{"], [:NAME, "port"], [:FARROW, "=>"], [:DQUOTE, "\""], [:NAME, "23"], [:DQUOTE, "\""], [:COMMA, ","], [:NAME, "protocol"], [:FARROW, "=>"], [:DQUOTE, "\""], [:NAME, "tcp"], [:DQUOTE, "\""], [:COMMA, ","], [:NAME, "name"], [:FARROW, "=>"], [:DQUOTE, "\""], [:NAME, "telnet"], [:DQUOTE, "\""], [:COMMA, ","], [:RBRACE, "}"]]
-
-class TestLexer < Test::Unit::TestCase
-	include PuppetTest
-    def setup
-        super
-        mklexer
-    end
-
-    def mklexer
-        @lexer = Puppet::Parser::Lexer.new()
-    end
-
-    def test_simple_lex
-        strings = {
-%q{\\} => [[:BACKSLASH,"\\"],[false,false]],
-%q{simplest scanner test} => [[:NAME,"simplest"],[:NAME,"scanner"],[:NAME,"test"],[false,false]],
-%q{returned scanner test
-} => [[:NAME,"returned"],[:NAME,"scanner"],[:NAME,"test"],[false,false]]
-        }
-        strings.each { |str,ary|
-            @lexer.string = str
-            assert_equal(
-                ary,
-                @lexer.fullscan()
-            )
-        }
-    end
-
-    def test_quoted_strings
-        strings = {
-%q{a simple "scanner" test
-} => [[:NAME,"a"],[:NAME,"simple"],[:DQTEXT,"scanner"],[:NAME,"test"],[false,false]],
-%q{a simple 'single quote scanner' test
-} => [[:NAME,"a"],[:NAME,"simple"],[:SQTEXT,"single quote scanner"],[:NAME,"test"],[false,false]],
-%q{a harder 'a $b \c"'
-} => [[:NAME,"a"],[:NAME,"harder"],[:SQTEXT,'a $b \c"'],[false,false]],
-%q{a harder "scanner test"
-} => [[:NAME,"a"],[:NAME,"harder"],[:DQTEXT,"scanner test"],[false,false]],
-%q{a hardest "scanner \"test\""
-} => [[:NAME,"a"],[:NAME,"hardest"],[:DQTEXT,'scanner "test"'],[false,false]],
-%q{a hardestest "scanner \"test\"
-"
-} => [[:NAME,"a"],[:NAME,"hardestest"],[:DQTEXT,'scanner "test"
-'],[false,false]],
-%q{function("call")} => [[:NAME,"function"],[:LPAREN,"("],[:DQTEXT,'call'],[:RPAREN,")"],[false,false]]
-}
-        strings.each { |str,array|
-            @lexer.string = str
-            assert_equal(
-                array,
-                @lexer.fullscan()
-            )
-        }
-    end
-
-    def test_errors
-        strings = %w{
-            ^
-        }
-        strings.each { |str|
-            @lexer.string = str
-            assert_raise(RuntimeError) {
-                @lexer.fullscan()
-            }
-        }
-    end
-
-    def test_more_error
-        assert_raise(TypeError) {
-            @lexer.fullscan()
-        }
-    end
-
-    def test_files
-        textfiles() { |file|
-            lexer = Puppet::Parser::Lexer.new()
-            lexer.file = file
-            assert_nothing_raised("Failed to lex %s" % file) {
-                lexer.fullscan()
-            }
-            Puppet::Type.allclear
-        }
-    end
-
-    def test_strings
-        names = %w{this is a bunch of names}
-        types = %w{Many Different Words A Word}
-        words = %w{differently Cased words A a}
-
-        names.each { |t|
-            @lexer.string = t
-            assert_equal(
-                [[:NAME,t],[false,false]],
-                @lexer.fullscan
-            )
-        }
-        types.each { |t|
-            @lexer.string = t
-            assert_equal(
-                [[:CLASSREF,t],[false,false]],
-                @lexer.fullscan
-            )
-        }
-    end
-
-    def test_emptystring
-        bit = '$var = ""'
-
-        assert_nothing_raised {
-            @lexer.string = bit
-        }
-
-        assert_nothing_raised {
-            @lexer.fullscan
-        }
-    end
-
-    def test_collectlexing
-        {"@" => :AT, "<|" => :LCOLLECT, "|>" => :RCOLLECT}.each do |string, token|
-            assert_nothing_raised {
-                @lexer.string = string
-            }
-
-            ret = nil
-            assert_nothing_raised {
-                ret = @lexer.fullscan
-            }
-
-            assert_equal([[token, string],[false, false]], ret)
-        end
-    end
-
-    def test_collectabletype
-        string = "@type {"
-
-        assert_nothing_raised {
-            @lexer.string = string
-        }
-
-        ret = nil
-        assert_nothing_raised {
-            ret = @lexer.fullscan
-        }
-
-        assert_equal([[:AT, "@"], [:NAME, "type"], [:LBRACE, "{"], [false,false]],ret)
-    end
-
-    def test_namespace
-        @lexer.string = %{class myclass}
-
-        assert_nothing_raised {
-            @lexer.fullscan
-        }
-
-        assert_equal("myclass", @lexer.namespace)
-
-        assert_nothing_raised do
-            @lexer.namepop
-        end
-
-        assert_equal("", @lexer.namespace)
-
-        @lexer.string = "class base { class sub { class more"
-
-        assert_nothing_raised {
-            @lexer.fullscan
-        }
-
-        assert_equal("base::sub::more", @lexer.namespace)
-
-        assert_nothing_raised do
-            @lexer.namepop
-        end
-
-        assert_equal("base::sub", @lexer.namespace)
-
-        # Now try it with some fq names
-        mklexer
-
-        @lexer.string = "class base { class sub::more {"
-
-        assert_nothing_raised {
-            @lexer.fullscan
-        }
-
-        assert_equal("base::sub::more", @lexer.namespace)
-
-        assert_nothing_raised do
-            @lexer.namepop
-        end
-
-        assert_equal("base", @lexer.namespace)
-    end
-
-    def test_indefine
-        @lexer.string = %{define me}
-
-        assert_nothing_raised {
-            @lexer.scan { |t,s| }
-        }
-
-        assert(@lexer.indefine?, "Lexer not considered in define")
-
-        # Now make sure we throw an error when trying to nest defines.
-        assert_raise(Puppet::ParseError) do
-            @lexer.string = %{define another}
-            @lexer.scan { |t,s| }
-        end
-
-        assert_nothing_raised do
-            @lexer.indefine = false
-        end
-
-        assert(! @lexer.indefine?, "Lexer still considered in define")
-    end
-
-    # Make sure the different qualified variables work.
-    def test_variable
-        ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable"].each do |string|
-            @lexer.string = string
-
-            assert_nothing_raised("Could not lex %s" % string) do
-                @lexer.scan do |t, s|
-                    assert_equal(:VARIABLE, t, "did not get variable as token")
-                    assert_equal(string.sub(/^\$/, ''), s, "did not get correct string back")
-                    break
-                end
-            end
-        end
-    end
-
-    # Make sure the expected stack works as it should
-    def test_expected
-        @lexer.string = "[a{"
-        expected = @lexer.instance_variable_get("@expected")
-        @lexer.scan {}
-        assert_equal("}", @lexer.expected, "expected value is wrong")
-
-        @lexer.string = "}"
-        @lexer.scan {}
-        assert_equal("]", @lexer.expected, "expected value is wrong after pop")
-    end
-
-    # #774
-    def test_classref_token
-        string = ["Foo", "::Foo","Foo::Bar","::Foo::Bar"]
-
-        string.each do |foo|
-            assert_nothing_raised {
-                @lexer.string = foo
-            }
-
-            ret = nil
-            assert_nothing_raised {
-                ret = @lexer.fullscan
-            }
-
-            assert_equal([:CLASSREF, foo],ret[0], "Did not correctly tokenize '%s'" % foo)
-        end
-    end
-end
-